备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

常用的几种内存池技术

2013-04-22 675
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：    几乎所有应用程序中都会有内存的分配和释放，而频繁的分配和释放内存无疑会产生内存碎片，降低系统性能，尤其对性能要求较高的程序比较明显。下面介绍几种常见的内存池技术。     一  环形缓存     环形缓存的基本原理如图：     初始化状态...
   几乎所有应用程序中都会有内存的分配和释放，而频繁的分配和释放内存无疑会产生内存碎片，降低系统性能，尤其对性能要求较高的程序比较明显。下面介绍几种常见的内存池技术。
    一  环形缓存
    环形缓存的基本原理如图：
    初始化状态(wpos_ = rpos_)：

    写了部分数据，同时读了一部分数据（wpos_ > rpos_）：

    wpos_写数据到尾部后，又从头开始，rpos_还读到尾部（wpos_
    rpos_读了N（N>= 1）圈后，赶上了wpos_,也就是说没有数据可读了(wpos_ )：

   综合起来，看起来像这样子：
 需要注意的是：
    #1    wpos_
    #2    如果 | wpos_ -  rpos |  
    部分实现代码如下：

点击(此处)折叠或打开

  1. #define EXTRA_BUFFER_SIZE        64

  3. namespace easy
  4. {
  5.     templateclass _Type,class _Alloc >
  6.     class EasyRingbuffer
  7.     {
  8.     public:
  9.         typedef _Alloc allocator_type;

  11.         explicit EasyRingbuffer(size_t size):
  12.         size_(size),
  13.             wpos_(0),
  14.             rpos_(0)
  15.         {
  16.             buffer_ = _allocate(size_);
  17.         }

  19.         ~EasyRingbuffer() { _deallocate(buffer_,size_); }

  21.         templatetypename T> void append(T val)
  22.         {
  23.             append((easy_uint8*)&val,sizeof(val));
  24.         }

  26.         void append(const easy_uint8* src, size_t cnt)
  27.         {
  28.             if (!cnt)
  29.             {
  30.                 return;
  31.             }

  33.             //    case 1: rpos_ = wpos_
  34.             if (rpos_ = wpos_)
  35.             {
  36.                 if (size_ - wpos_ >= cnt)
  37.                 {
  38.                     memmove(buffer_ + wpos_,src,cnt);
  39.                     wpos_ += cnt;
  40.                     return;
  41.                 }
  42.                 else
  43.                 {
  44.                     if (size_ - wpos_ + rpos_ > cnt)    // >= is ok>
  45.                     {
  46.                         memmove(buffer_ + wpos_, src, size_ - wpos_);
  47.                         memmove(buffer_, src + size_ - wpos_, cnt - (size_ - wpos_));
  48.                         wpos_ = cnt - (size_ - wpos_);
  49.                         return;
  50.                     }
  51.                     else
  52.                     {
  53.                         _Type* new_buffer = _allocate(size_ + cnt - (size_ - wpos_));
  54.                         memmove(new_buffer,buffer_,wpos_);
  55.                         memmove(new_buffer + wpos_, src, cnt);
  56.                         _deallocate(buffer_,size_);
  57.                         size_ = size_ + cnt - (size_ - wpos_);
  58.                         wpos_ += cnt;
  59.                         buffer_ = new_buffer;
  60.                         return;
  61.                     }
  62.                 }
  63.             }
  64.             //    case 2: rpos_ > wpos_
  65.             else if(rpos_ > wpos_)
  66.             {
  67.                 if (rpos_ - wpos_ > cnt)    // >= is ok ?
  68.                 {
  69.                     if (rpos_ - wpos_ > cnt)
  70.                     {
  71.                         memmove(buffer_ + wpos_,src,cnt);
  72.                         wpos_ += cnt;
  73.                         return;
  74.                     }
  75.                     else
  76.                     {
  77.                         _Type* new_buffer = _allocate(size_ + cnt - (rpos_ - wpos_) + EXTRA_BUFFER_SIZE);
  78.                         memmove(new_buffer,buffer_,wpos_);
  79.                         memmove(new_buffer + wpos_,src,cnt);
  80.                         memmove(new_buffer + wpos_ + cnt - (rpos_ - wpos_) + EXTRA_BUFFER_SIZE,buffer_ + rpos_,size_ - rpos_);
  81.                         _deallocate(buffer_,size_);
  82.                         rpos_ += cnt - (rpos_ - wpos_) + EXTRA_BUFFER_SIZE;
  83.                         wpos_ += cnt;
  84.                         size_ = size_ + cnt - (rpos_ - wpos_) + EXTRA_BUFFER_SIZE;
  85.                         buffer_ = new_buffer;
  86.                         return;
  87.                     }
  88.                 }
  89.             }
  90.         }

  92.         EasyRingbuffer& operator (easy_bool val)
  93.         {
  94.             appendeasy_bool>(val);
  95.             return *this;
  96.         }

  98.         EasyRingbuffer& operator (easy_uint8 val)
  99.         {
  100.             appendeasy_uint8>(val);
  101.             return *this;
  102.         }

  104.         EasyRingbuffer& operator (easy_uint16 val)
  105.         {
  106.             appendeasy_uint16>(val);
  107.             return *this;
  108.         }

  110.         EasyRingbuffer& operator (easy_uint32 val)
  111.         {
  112.             appendeasy_uint32>(val);
  113.             return *this;
  114.         }

  116.         EasyRingbuffer& operator (easy_uint64 val)
  117.         {
  118.             appendeasy_uint64>(val);
  119.             return *this;
  120.         }

  122.         EasyRingbuffer& operator (easy_int8 val)
  123.         {
  124.             appendeasy_int8>(val);
  125.             return *this;
  126.         }

  128.         EasyRingbuffer& operator (easy_int16 val)
  129.         {
  130.             appendeasy_int16>(val);
  131.             return *this;
  132.         }

  134.         EasyRingbuffer& operator (easy_int32 val)
  135.         {
  136.             appendeasy_int32>(val);
  137.             return *this;
  138.         }

  140.         EasyRingbuffer& operator (easy_int64 val)
  141.         {
  142.             appendeasy_int64>(val);
  143.             return *this;
  144.         }

  146.         EasyRingbuffer& operator (easy_float val)
  147.         {
  148.             appendeasy_float>(val);
  149.             return *this;
  150.         }

  152.         EasyRingbuffer& operator (easy_double val)
  153.         {
  154.             appendeasy_double>(val);
  155.             return *this;
  156.         }

  158.         EasyRingbuffer& operator (const std::string& val)
  159.         {
  160.             append((easy_uint8 const*)val.c_str(),val.length());
  161.             return *this;
  162.         }

  164.         EasyRingbuffer& operator (const char* val)
  165.         {
  166.             append((easy_uint8 const *)val, val ? strlen(val) : 0);
  167.             return *this;
  168.         }

  170.         templatetypename T> T read()
  171.         {
  172.             T r;
  173.             read((easy_uint8*)&r,sizeof(T));
  174.             return r;
  175.         }

  177.         void read(easy_uint8* des,size_t len)
  178.         {
  179.             if (_read_finish())
  180.             {
  181.                 return;
  182.             }
  183.             if (rpos_ wpos_)
  184.             {
  185.                 if (wpos_ - rpos_ >= len)
  186.                 {
  187.                     memmove(des,buffer_ + rpos_,len);
  188.                     rpos_ += len;
  189.                 }
  190.                 //    else just skip
  191.             }
  192.             else if (rpos_ > wpos_)
  193.             {
  194.                 if (size_ - rpos_ >= len)
  195.                 {
  196.                     memmove(des,buffer_ + rpos_,len);
  197.                     rpos_ += len;
  198.                 }
  199.                 else
  200.                 {
  201.                     memmove(des,buffer_ + rpos_, size_ - rpos_);
  202.                     memmove(des + size_ - rpos_, buffer_, len - (size_ - rpos_));
  203.                     rpos_ = len - (size_ - rpos_);
  204.                 }
  205.             }
  206.         }

  208.         EasyRingbuffer& operator >> (easy_bool& val)
  209.         {
  210.             val = readeasy_bool>();
  211.             return *this;
  212.         }

  214.         EasyRingbuffer& operator >> (easy_uint8& val)
  215.         {
  216.             val = readeasy_uint8>();
  217.             return *this;
  218.         }

  220.         EasyRingbuffer& operator >> (easy_uint16& val)
  221.         {
  222.             val = readeasy_uint16>();
  223.             return *this;
  224.         }

  226.         EasyRingbuffer& operator >> (easy_uint32& val)
  227.         {
  228.             val = readeasy_uint32>();
  229.             return *this;
  230.         }

  232.         EasyRingbuffer& operator >> (easy_uint64& val)
  233.         {
  234.             val = readeasy_uint64>();
  235.             return *this;
  236.         }

  238.         EasyRingbuffer& operator >> (easy_int8& val)
  239.         {
  240.             val = readeasy_int8>();
  241.             return *this;
  242.         }

  244.         EasyRingbuffer& operator >> (easy_int16& val)
  245.         {
  246.             val = readeasy_int16>();
  247.             return *this;
  248.         }

  250.         EasyRingbuffer& operator >> (easy_int32& val)
  251.         {
  252.             val = readeasy_int32>();
  253.             return *this;
  254.         }

  256.         EasyRingbuffer& operator >> (easy_int64& val)
  257.         {
  258.             val = readeasy_int64>();
  259.             return *this;
  260.         }

  262.         EasyRingbuffer& operator >> (easy_float& val)
  263.         {
  264.             val = readeasy_float>();
  265.             return *this;
  266.         }

  268.         EasyRingbuffer& operator >> (easy_double& val)
  269.         {
  270.             val = readeasy_double>();
  271.             return *this;
  272.         }

  274.         size_t size() const { return size_; }

  276.         size_t rpos() const { return rpos_; }

  278.         size_t wpos() const { return wpos_; }

  280.     private:
  281.         _Type* _allocate(size_t size)
  282.         {
  283.             _Type* res = 0;
  284.             res = static_cast_Type*>(alloc_type_.allocate(size));
  285.             return res;
  286.         }

  288.         void _deallocate(void* p,size_t size)
  289.         {
  290.             alloc_type_.deallocate(p,size);
  291.         }

  293.         void _reallocate(void* p,size_t old_size,size_t new_size) { alloc_type_.reallocate(p,old_size,new_size); }

  295.         easy_bool _read_finish() { return wpos_ == rpos_; }

  297.     private:
  298.         EasyRingbuffer ( const EasyRingbuffer& );
  299.         EasyRingbuffer& operator = ( const EasyRingbuffer& );
  300.     private:
  301.         size_t            size_;

  303.         _Type*            buffer_;

  305.         size_t            wpos_;

  307.         size_t            rpos_;

  309.         allocator_type    alloc_type_;
  310.     };
  311. }
 
  二 空闲列表
    空闲列表的原理比较简单，一般用于比较大的对象，可预分配一定数量的对象，需要时直接空闲列表中取，使用完后收回，如果空闲列表中已空，则需要重新设置大小了；也可使用时分配，使用完后收回。实现代码如下：

点击(此处)折叠或打开

  1. // use stl
  2.     templatetypename _Type, typename _Lock,typename _StorageType /*= std::list_Type*>*/>
  3.     class lock_queue     
  4.     {
  5.         typedef typename _Type::_Key                _Key;

  7.         static const size_t MAX_POOL_SIZE = _Type::MAX_POOL_SIZE;

  9.     public:
  10.         _Type* allocate(_Key __key)
  11.         {
  12.             _Type* __ret = 0;
  13.             if (free_list_.empty())
  14.             {
  15.                 __ret = new _Type(__key);
  16.             }
  17.             else
  18.             {
  19.                 lock_.acquire_lock();
  20.                 __ret = free_list_.back();
  21.                 free_list_.pop_back();
  22.                 lock_.release_lock();
  23.             }
  24.             return __ret;
  25.         }

  27.         void deallcate(_Type* __val)
  28.         {
  29.             if (!__val)
  30.             {
  31.                 return;
  32.             }
  33.             if (MAX_POOL_SIZE free_list_.size())
  34.             {
  35.                 delete __val;
  36.                 return;
  37.             }
  38.             lock_.acquire_lock();
  39.             free_list_.push_back(__val);
  40.             lock_.release_lock();
  41.         }

  43.         size_t free_size() /*const*/
  44.         {
  45.             size_t __size = 0;
  46.             lock_.acquire_lock();
  47.             __size = free_list_.size();
  48.             lock_.release_lock();
  49.             return __size;
  50.         }

  52.         void clear()
  53.         {
  54.             lock_.acquire_lock();
  55.             for (typename _StorageType::iterator __it = free_list_.begin(); __it != free_list_.end(); ++__it)
  56.             {
  57.                 if ((*__it))
  58.                 {
  59.                     delete (*__it);
  60.                     (*__it) = NULL;
  61.                 }
  62.             }
  63.             free_list_.clear();
  64.             _StorageType().swap(free_list_);
  65.             lock_.release_lock();
  66.         }

  68.         ~lock_queue()
  69.         {
  70.             clear();
  71.         }
  72.     private:
  73.         _Lock                        lock_;
  74.         _StorageType                free_list_;
  75.     };

点击(此处)折叠或打开

  1. //anther way,use use stl
  2. template typename T, int DEFAULT_BLOCK_NUM = 1024 >
  3. class CMemoryPool
  4. {
  5. public:
  6.     static VOID* operator new ( std::size_t nAllocLength )
  7.     {
  8.         Assert( sizeof(T) == nAllocLength );
  9.         Assert( sizeof(T) >= sizeof(UCHAR*) );
  10.         if ( !m_sNewPointer )
  11.         {
  12.             allocBlock();
  13.         }
  14.         UCHAR* ucReturnPointer = m_sNewPointer;
  15.         //the head of 4 bytes is explain the next pointer of memory force,
  16.         //and m_NewPointer just point the next block of memory,when used the next allocation
  17.         m_sNewPointer = *reinterpret_castUCHAR**>( ucReturnPointer);
  18.         return ucReturnPointer;
  19.     }

  21.     static VOID operator delete( void* vpDeletePointer )
  22.     {
  23.         *reinterpret_castUCHAR**>( vpDeletePointer) = m_sNewPointer;    
  24.         m_sNewPointer = static_castUCHAR*>(vpDeletePointer);
  25.     }

  27.     static VOID allocBlock()
  28.     {
  29.         m_sNewPointer = new UCHAR[sizeof(T) * DEFAULT_BLOCK_NUM];
  30.         //casting dual pointer force,that will change the meaning of the head of 4 byte memory
  31.         UCHAR **ppCurent = reinterpret_castUCHAR**>( m_sNewPointer );
  32.         UCHAR *ppNext = m_sNewPointer;
  33.         for( int i = 0; i DEFAULT_BLOCK_NUM-1; i++ )
  34.         {
  35.             ppNext += sizeof(T);
  36.             *ppCurent = ppNext;
  37.             //the head of 4 bytes is explain the next pointer of memory force,a memory list in form.
  38.             ppCurent = reinterpret_castUCHAR**>( ppNext );
  39.         }
  40.         //if the last memory bock, the head of 4 byte is null
  41.         *ppCurent = 0;
  42.     }

  44. protected:
  45.     virtual ~CMemoryPool()
  46.     {

  48.     }
  49. private:
  50.     static UCHAR *m_sNewPointer;
  51. };

  53. templateclass T, int BLOCK_NUM >
  54. UCHAR *CMemoryPoolT, BLOCK_NUM >::m_sNewPointer;

    三  stl的二级分配器
    stl内部实现的分配器分两种情况：一种是大于128byte的分配，直接使用系统的内存分配函数malloc/free;另外一种为小于128byte的，也就是上面说的二级分配器，它采用了某些技术来管来内存，避免频繁分配释放。简单的说，就是将内存按8字节对齐，分别建立固定值倍数大小的内存池，如8, 8*2 ,8*3..., 当需要分配内存时，根据分配内存的大小，算出所需内存大小的内存池索引，然后根据这个索引找到那块内存池，并从中取出一块返回；同样，内存使用完后，按类似的方法回收。这种方案一般适用于比较小的内存分配的情况，大的可以考虑其他的方案。其流程如下：


下面是具体代码：

点击(此处)折叠或打开

  1. template bool threads, int inst >
  2.     class __default_alloc_template
  3.     {
  4.         enum {_ALIGN = 8};
  5.         enum {_MAX_BYTES = 128};
  6.         enum {_NFREELISTS = 16}; // _MAX_BYTES/_ALIGN
  7.     
  8.         static size_t _S_round_up(size_t __bytes) { return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); }

  10.         static size_t _S_freelist_index(size_t __bytes) { return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1); }

  12.         union _Obj
  13.         {
  14.             union _Obj* _M_free_list_link;
  15.             char _M_client_data[1]; /* The client sees this. */
  16.         };
  17.         static _Obj* volatile _S_free_list[_NFREELISTS];

  19.         // Returns an object of size __n, and optionally adds to size __n free list.
  20.         static void* _S_refill(size_t __n);

  22.         // Allocates a chunk for nobjs of size size. nobjs may be reduced
  23.         // if it is inconvenient to allocate the requested number.
  24.         static char* _S_chunk_alloc(size_t __size, int& __nobjs);

  26.         static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz);

  28.         // Chunk allocation state.
  29.         static char*    _S_start_free;
  30.         static char*    _S_end_free;
  31.         static size_t    _S_heap_size;

  33.     public:
  34.         static void* allocate(size_t __n)
  35.         {
  36.             void* __ret = 0;
  37.             if (__n > (size_t) _MAX_BYTES)
  38.             {
  39.                 __ret = malloc_alloc::allocate(__n);
  40.             }
  41.             else
  42.             {
  43.                 mutex_lock    __lock;
  44.                 __lock.acquire_lock();
  45.                 _Obj* volatile* __my_free_list = _S_free_list + _S_freelist_index(__n);
  46.                 _Obj* volatile __result = *__my_free_list;
  47.                 if (__result == 0)
  48.                 {
  49.                     __ret = _S_refill(_S_round_up(__n));
  50.                 }
  51.                 else
  52.                 {
  53.                     *__my_free_list = __result -> _M_free_list_link;
  54.                     __ret = __result;
  55.                 }
  56.                 __lock.release_lock();
  57.             }
  58.             return __ret;
  59.         }

  61.         /* __p may not be 0 */
  62.         static void deallocate(void* __p, size_t __n)
  63.         {
  64.             if (__n > (size_t) _MAX_BYTES)
  65.             {
  66.                  malloc_alloc::deallocate(__p, __n);
  67.             }
  68.             else
  69.             {
  70.                 mutex_lock    __lock;
  71.                 __lock.acquire_lock();
  72.                  _Obj* volatile* __my_free_list = _S_free_list + _S_freelist_index(__n);
  73.                  _Obj* __q = (_Obj*)__p;
  74.                  __q -> _M_free_list_link = *__my_free_list;
  75.                  *__my_free_list = __q;
  76.                  __lock.release_lock();
  77.             }
  78.         }
  79.     };

  81.     template bool __threads, int __inst>
  82.     inline bool operator==(const __default_alloc_template__threads, __inst>&,
  83.         const __default_alloc_template__threads, __inst>&)
  84.     {
  85.         return true;
  86.     }

  88.     template bool __threads, int __inst>
  89.     inline bool operator!=(const __default_alloc_template__threads, __inst>&,
  90.         const __default_alloc_template__threads, __inst>&)
  91.     {
  92.         return false;
  93.     }

  95.     /* We allocate memory in large chunks in order to avoid fragmenting */
  96.     /* the malloc heap too much. */
  97.     /* We assume that size is properly aligned. */
  98.     /* We hold the allocation lock. */
  99.     template bool __threads, int __inst>
  100.     char*    __default_alloc_template__threads, __inst>::_S_chunk_alloc(size_t __size, int& __nobjs)
  101.     {
  102.         //::_set_new_handler(_out_of_memory);
  103.         char* __result;
  104.         size_t __total_bytes = __size * __nobjs;
  105.         size_t __bytes_left = _S_end_free - _S_start_free;
  106.         //    enough memory to alloc
  107.         if (__bytes_left >= __total_bytes)
  108.         {
  109.             __result = _S_start_free;
  110.             _S_start_free += __total_bytes;
  111.             return(__result);
  112.         }
  113.         //    only more than __size can be alloc
  114.         else if (__bytes_left >= __size)
  115.         {
  116.             __nobjs = (int)(__bytes_left/__size);
  117.             __total_bytes = __size * __nobjs;
  118.             __result = _S_start_free;
  119.             _S_start_free += __total_bytes;
  120.             return(__result);
  121.         }
  122.         else
  123.         {
  124.             size_t __bytes_to_get = 2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
  125.             // Try to make use of the left-over piece.
  126.             if (__bytes_left > 0)
  127.             {
  128.                 _Obj* volatile* __my_free_list = _S_free_list + _S_freelist_index(__bytes_left);
  129.                 ((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;
  130.                 *__my_free_list = (_Obj*)_S_start_free;
  131.             }
  132.             //    alloc __bytes_to_get again
  133.             _S_start_free = (char*)malloc(__bytes_to_get);

  135.             //    alloc failed
  136.             if (0 == _S_start_free)
  137.             {
  138.                 size_t __i;
  139.                 _Obj* volatile* __my_free_list;
  140.                 _Obj* __p;
  141.                 // Try to make do with what we have. That can't
  142.                 // hurt. We do not try smaller requests, since that tends
  143.                 // to result in disaster on multi-process machines.
  144.                 for (__i = __size; __i = (size_t) _MAX_BYTES; __i += (size_t) _ALIGN)
  145.                 {
  146.                     __my_free_list = _S_free_list + _S_freelist_index(__i);
  147.                     __p = *__my_free_list;
  148.                     if (0 != __p)
  149.                     {
  150.                         *__my_free_list = __p -> _M_free_list_link;
  151.                         _S_start_free = (char*)__p;
  152.                         _S_end_free = _S_start_free + __i;
  153.                         return(_S_chunk_alloc(__size, __nobjs));
  154.                         // Any leftover piece will eventually make it to the
  155.                         // right free list.
  156.                     }
  157.                 }
  158.                 _S_end_free = 0;    // In case of exception.
  159.                 _S_start_free = (char*) malloc(__bytes_to_get);
  160.                 // This should either throw an
  161.                 // exception or remedy the situation. Thus we assume it
  162.                 // succeeded.
  163.             }
  164.             _S_heap_size += __bytes_to_get;
  165.             _S_end_free = _S_start_free + __bytes_to_get;
  166.             return(_S_chunk_alloc(__size, __nobjs));
  167.         }
  168.     }

  170.     /* Returns an object of size __n, and optionally adds to size __n free list.*/
  171.     /* We assume that __n is properly aligned. */
  172.     /* We hold the allocation lock. */
  173.     template bool __threads, int __inst>
  174.     void* __default_alloc_template__threads, __inst>::_S_refill(size_t __n)
  175.     {
  176.         int __nobjs = 20;
  177.         char* __chunk = _S_chunk_alloc(__n, __nobjs);
  178.         _Obj* volatile* __my_free_list;
  179.         _Obj* __result;
  180.         _Obj* __current_obj;
  181.         _Obj* __next_obj;
  182.         int __i;

  184.         if (1 == __nobjs)
  185.         {
  186.             return(__chunk);
  187.         }
  188.         __my_free_list = _S_free_list + _S_freelist_index(__n);

  190.         /* Build free list in chunk */
  191.         __result = (_Obj*)__chunk;
  192.         *__my_free_list = __next_obj = (_Obj*)(__chunk + __n);
  193.         for (__i = 1; ; __i++)
  194.         {
  195.             __current_obj = __next_obj;
  196.             __next_obj = (_Obj*)((char*)__next_obj + __n);
  197.             if (__nobjs - 1 == __i)
  198.             {
  199.                 __current_obj -> _M_free_list_link = 0;
  200.                 break;
  201.             }
  202.             else
  203.             {
  204.                 __current_obj -> _M_free_list_link = __next_obj;
  205.             }
  206.         }
  207.         return(__result);
  208.     }

  210.     template bool threads, int inst>
  211.     void* __default_alloc_templatethreads, inst>::reallocate(void* __p, size_t __old_sz, size_t __new_sz)
  212.     {
  213.         mutex_lock    __lock;
  214.         __lock.acquire_lock();
  215.         void* __result;
  216.         size_t __copy_sz;

  218.         if (__old_sz > (size_t) _MAX_BYTES && __new_sz > (size_t) _MAX_BYTES)
  219.         {
  220.             __lock.release_lock();
  221.             return(realloc(__p, __new_sz));
  222.         }
  223.         if (_S_round_up(__old_sz) == _S_round_up(__new_sz))
  224.         {
  225.             __lock.release_lock();
  226.             return(__p);
  227.         }
  228.         __result = allocate(__new_sz);
  229.         __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
  230.         memcpy(__result, __p, __copy_sz);
  231.         deallocate(__p, __old_sz);
  232.         __lock.release_lock();
  233.         return(__result);
  234.     }

  236.     template bool threads, int inst >
  237.     char* __default_alloc_templatethreads, inst>::_S_start_free = 0;

  239.     template bool threads, int inst >
  240.     char* __default_alloc_templatethreads, inst>::_S_end_free = 0;

  242.     template bool threads, int inst >
  243.     size_t __default_alloc_templatethreads, inst>::_S_heap_size = 0;

  245.     template bool __threads, int __inst>
  246.     typename __default_alloc_template__threads, __inst>::_Obj* volatile
  247.         __default_alloc_template__threads, __inst> ::_S_free_list[_NFREELISTS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };

 参考：
    sqi stl
      http://www.sgi.com/tech/stl/
文章标签：
C++
索引
缓存
nothingfinal
目录
相关文章
高二的笔记
|
3月前
3.1.2 内存池的实现与场景分析
3.1.2 内存池的实现与场景分析
高二的笔记
37 0
LionLong
|
6月前
|
算法 应用服务中间件 nginx
超越内存限制：深入探索内存池的工作原理与实现
这篇文章将深入探索内存池的工作原理与实现，介绍如何超越传统的内存限制。首先，我们将了解什么是内存池以及它与传统内存分配方式的不同之处。接着，我们将探索内存池的工作原理，包括内存池的数据结构和算法。我们还将解释内存池如何提升性能，避免内存碎片化，并减少内存分配的开销。此外，我们将介绍一些常见的内存池实现技术，例如固定大小内存池和动态大小内存池，并对比它们的优劣之处。
LionLong
43 0
泡沫o0
|
29天前
|
算法 数据库连接 程序员
深度剖析：C++内存池的设计与实现
深度剖析：C++内存池的设计与实现
泡沫o0
49 0
码农~
|
3月前
|
应用服务中间件 nginx
内存池的实现与分析
内存池的实现与分析
码农~
25 0
整日摸鱼的小黑猫
|
3月前
|
应用服务中间件 nginx
内存池的实现
内存池的实现
整日摸鱼的小黑猫
28 0
程韬123
|
4月前
|
存储
内存池的实现与场景分析
内存池的实现与场景分析
程韬123
39 0
猿长大人
|
4月前
|
存储 C#
C# | 内存池
内存池可以复用已申请的内存空间，它在程序启动时预先分配一定数量的内存块，当你需要使用内存时，则会从内存池中分配一块空闲内存，也就是说并不是每次都会向系统申请一块新的内存空间。 同理，当你使用完一块内存空间后，并不是直接释放内存，而是将其归还到内存池中。内存池就是通过这样一借一还的方式避免了频繁地分配和释放内存，减少了内存碎片和系统开销，提高了程序的性能。
猿长大人
36 0
Linux开发架构之路
|
5月前
|
存储 缓存 Linux
万字详解C++内存池：提高内存分配效率的利器（下）
万字详解C++内存池：提高内存分配效率的利器
Linux开发架构之路
67 0
Linux开发架构之路
|
5月前
|
存储 机器学习/深度学习 缓存
万字详解C++内存池：提高内存分配效率的利器（上）
万字详解C++内存池：提高内存分配效率的利器
Linux开发架构之路
128 0
万字详解C++内存池：提高内存分配效率的利器（上）
游客6nmtzqmqofvbk
|
11月前
|
存储 Java 编译器
【高并发内存池】第一篇：定长内存池设计
内存池是池化技术的一种应用。所谓“池化技术”，就是程序先向系统申请过量的资源，然后自己管理，以备不时之需。之所以要申请过量的资源，是因为每次申请该资源都有较大的开销，不如提前申请好了，这样使用时就会变得非常快捷，大大提高程序运行效率。
游客6nmtzqmqofvbk
366 1

热门文章

最新文章

  • 1
    随机生成UserAgent的python库（fake-useragent库）
  • 2
    使用zxing识别一幅包含多个二维码的图片
  • 3
    阿里云的SLB，植入cookie和重写cookie有什么区别？
  • 4
    基于Flink的实时日志分析系统实践
  • 5
    如何在服务器上跑python程序
  • 6
    电池技术多年没有较大发展，成为移动设备最大制约
  • 7
    Spread for WinRT 7新功能使用指南
  • 8
    codeforces Soldier and Number Game（dp+素数筛选）
  • 9
    九度oj-1001-Java
  • 10
    Android:随笔——对页面的View进行截图
  • 1
    分解商业周期时间序列：线性滤波器、HP滤波器、Baxter滤波器、Beveridge Nelson分解等去趋势2
    9
  • 2
    分解商业周期时间序列：线性滤波器、HP滤波器、Baxter滤波器、Beveridge Nelson分解等去趋势法1
    9
  • 3
    灰色关联分析(Grey Relation Analysis,GRA)中国经济社会发展指标
    9
  • 4
    极值分析：分块极大值BLOCK-MAXIMA、阈值超额法、广义帕累托分布GPD拟合降雨数据时间序列
    9
  • 5
    GARCH-DCC模型和DCC（MVT）建模估计
    8
  • 6
    ARIMA、ARIMAX、 动态回归和OLS 回归预测多元时间序列
    10
  • 7
    R语言预测期货波动率的实现：ARCH与HAR-RV与GARCH，ARFIMA模型比较
    10
  • 8
    spss modeler用决策树神经网络预测ST的股票
    9
  • 9
    K-means和层次聚类分析癌细胞系微阵列数据和树状图可视化比较
    8
  • 10
    matlab中使用VMD(变分模态分解)对信号去噪
    8

    • 相关电子书

    更多
  • 内存取证与IaaS云平台恶意行 为的安全监控
  • 云服务器ECS内存增强型实例re6全新发布
  • 低代码开发师（初级）实战教程
    • 下一篇
    阿里云oss简介和使用流程
    为什么选择阿里云什么是云计算全球基础设施技术领先稳定可靠安全合规分析师报告
    产品和定价全部产品免费试用产品动态产品定价价格计算器云上成本管理
    解决方案技术解决方案
    文档与社区文档开发者社区天池大赛培训与认证
    权益中心免费试用高校计划企业扶持计划推荐返现计划
    支持与服务基础服务企业增值服务迁云服务官网公告健康看板信任中心
    关注阿里云
    关注阿里云公众号或下载阿里云APP，关注云资讯，随时随地运维管控云服务
    阿里云APP阿里云微信
    联系我们：4008013260
    法律声明Cookies政策廉正举报安全举报联系我们加入我们
    阿里巴巴集团淘宝网天猫全球速卖通阿里巴巴国际交易市场1688阿里妈妈飞猪阿里云计算AliOS万网高德UC友盟优酷钉钉支付宝达摩院淘宝海外阿里云盘饿了么
    © 2009-2024 Aliyun.com 版权所有 增值电信业务经营许可证： 浙B2-20080101 域名注册服务机构许可： 浙D3-20210002 京D3-20220015
    浙公网安备 33010602009975号浙B2-20080101-4