AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

常用的几种内存池技术

2013-04-22 915
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：    几乎所有应用程序中都会有内存的分配和释放，而频繁的分配和释放内存无疑会产生内存碎片，降低系统性能，尤其对性能要求较高的程序比较明显。下面介绍几种常见的内存池技术。     一  环形缓存     环形缓存的基本原理如图：     初始化状态...
   几乎所有应用程序中都会有内存的分配和释放，而频繁的分配和释放内存无疑会产生内存碎片，降低系统性能，尤其对性能要求较高的程序比较明显。下面介绍几种常见的内存池技术。
    一  环形缓存
    环形缓存的基本原理如图：
    初始化状态(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++
索引
缓存
关键词：
内存技术
xumaojun
目录
相关文章
尹正杰
|
4月前
|
KVM 虚拟化
KVM的热添加技术之内存
文章介绍了KVM虚拟化技术中如何通过命令行调整虚拟机内存配置，包括调小和调大内存的步骤，以及一些相关的注意事项。
尹正杰
104 4
KVM的热添加技术之内存
蚝油菜花
|
25天前
|
人工智能 物联网 C语言
SVDQuant：MIT 推出的扩散模型后训练的量化技术，能够将模型的权重和激活值量化至4位，减少内存占用并加速推理过程
SVDQuant是由MIT研究团队推出的扩散模型后训练量化技术，通过将模型的权重和激活值量化至4位，显著减少了内存占用并加速了推理过程。该技术引入了高精度的低秩分支来吸收量化过程中的异常值，支持多种架构，并能无缝集成低秩适配器（LoRAs），为资源受限设备上的大型扩散模型部署提供了有效的解决方案。
蚝油菜花
49 5
SVDQuant：MIT 推出的扩散模型后训练的量化技术，能够将模型的权重和激活值量化至4位，减少内存占用并加速推理过程
1387503158665997
|
4月前
ARM64技术 —— MMU处于关闭状态时，内存访问是怎样的？
ARM64技术 —— MMU处于关闭状态时，内存访问是怎样的？
1387503158665997
79 1
丰宝宝
|
6月前
|
机器学习/深度学习 存储 缓存
操作系统中的内存管理技术
在数字世界的复杂架构中，操作系统扮演着枢纽的角色，其中内存管理作为其核心组件之一，保障了计算资源的高效利用与稳定运行。本文将深入探讨操作系统中内存管理的关键技术，包括虚拟内存、分页和分段机制，以及现代操作系统如何通过这些技术优化性能和提高系统稳定性。通过具体实例和数据分析，我们将揭示这些技术如何在实际应用中发挥作用，并讨论它们面临的挑战及未来发展方向。 【7月更文挑战第16天】
丰宝宝
117 6
1941623231718325
|
6月前
|
存储 缓存 Java
Android性能优化：内存管理与LeakCanary技术详解
【7月更文挑战第21天】内存管理是Android性能优化的关键部分，而LeakCanary则是进行内存泄漏检测和修复的强大工具。
1941623231718325
240 1
技术混子
|
6月前
|
物联网 云计算
操作系统中的内存管理技术解析
【7月更文挑战第13天】本文将深入探讨操作系统中至关重要的内存管理技术，包括虚拟内存、分页和分段机制等核心概念。我们将从内存管理的基本原理出发，逐步过渡到高级技术如交换空间和文件映射，最后讨论现代操作系统中内存管理面临的挑战与未来发展方向。文章旨在为读者提供对操作系统内存管理全面而深入的理解。
技术混子
94 7
weixin_836869520
|
6月前
|
存储 缓存 NoSQL
Java中的内存数据库与缓存技术
Java中的内存数据库与缓存技术
weixin_836869520
118 1
帅政的oss
|
7月前
|
存储 算法
探索现代操作系统中的虚拟内存管理技术
在数字时代的浪潮中，操作系统的心脏——虚拟内存管理技术，正以它独有的韵律跳动。本文将带你穿梭于操作系统的迷宫，揭开虚拟内存如何巧妙地扩展有限的物理内存之谜。从分页机制的精妙设计到交换空间的策略运用，我们将一探究竟。你将看到，虚拟内存不仅仅是一个存储数据的地方，它是速度与效率的协调者，是多任务处理的幕后英雄。随着技术的演进，虚拟内存管理不断优化，为应用程序提供了一片更为广阔的运行天地。让我们一同走进这个充满智慧的世界，感受操作系统中虚拟内存管理的魅力所在。
帅政的oss
64 1
xibeijing
|
6月前
|
存储 缓存 安全
操作系统中的内存管理：技术与挑战
在数字化时代，操作系统的内存管理成为计算机科学领域中一个至关重要的技术环节。本文将深入探讨现代操作系统中内存管理的基本原理、关键技术及其面临的挑战。通过对分页、分段、虚拟存储和缓存策略等核心概念的介绍，我们旨在揭示内存管理如何优化系统性能，保障数据安全，并提高资源利用率。同时，文章还将讨论内存泄漏、碎片化以及安全性问题等当前内存管理技术所面临的主要挑战。
xibeijing
87 0
郑小健
|
7月前
|
存储 消息中间件 缓存
Redis：内存数据存储与缓存系统的技术探索
**Redis 概述与最佳实践** Redis，全称Remote Dictionary Server，是流行的内存数据结构存储系统，常用于数据库、缓存和消息中介。它支持字符串、哈希、列表等数据结构，并具备持久化、主从复制、集群部署及发布/订阅功能。Redis适用于缓存系统、计数器、消息队列、分布式锁和实时系统等场景。最佳实践包括选择合适的数据结构、优化缓存策略、监控调优、主从复制与集群部署以及确保安全配置。
郑小健
126 3

热门文章

最新文章

  • 1
    如何使用内存监控工具来优化 Node.js 应用的性能
  • 2
    深入理解Linux内核的内存管理机制
  • 3
    Docker容器性能调优的关键技巧，涵盖CPU、内存、网络及磁盘I/O的优化策略，结合实战案例，旨在帮助读者有效提升Docker容器的性能与稳定性。
  • 4
    C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略，涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
  • 5
    深入探索Java虚拟机（JVM）的内存管理机制
  • 6
    【C语言】内存管理函数详细讲解
  • 7
    阿里云服务器经济型e、通用算力型u1、计算型c8i、通用型g8i、内存型r8i实例介绍与选择参考
  • 8
    深入探索Android系统的内存管理机制
  • 9
    Java 内存管理与优化：掌控堆与栈，雕琢高效代码
  • 10
    基于内存认证的 Spring Security
  • 1
    Python内存管理与垃圾回收机制
    71
  • 2
    【MongoDB 专栏】MongoDB 的内存管理与优化
    369
  • 3
    JavaScript的垃圾回收机制通过标记-清除算法自动管理内存
    63
  • 4
    LabVIEW使用数据引用减少内存
    80
  • 5
    linux上如何排查JVM内存过高？
    1103
  • 6
    Redis内存分析工具RDR
    1780
  • 7
    LabVIEW中CPU和内存使用情况在NI分布式系统管理器中不可见
    92
  • 8
    LabVIEW监控实时嵌入式目标上的CPU和内存使用情况
    288
  • 9
    LabVIEW最大内存块属性不存在
    44
  • 10
    LabVIEW性能和内存管理 8
    75

    • 相关电子书

    更多
  • 内存取证与IaaS云平台恶意行 为的安全监控
  • 云服务器ECS内存增强型实例re6全新发布
  • 低代码开发师（初级）实战教程
    • 下一篇
    开通oss服务