qqsunkist

STL容器默认的内存分配器（std::alloc）           

allocator std::alloc memory pool freelist. 

STL容器默认的内存分配器（std::alloc）

STL中的容器类的class templates，最后一个template parameter就是alloc，而默认值便是std::alloc。对象构造前的空间配置与对象析构后的空间释放，由<bits/stl_alloc.h>负责，SGI设计此库时，主要有以下几个考虑因素：

  1. 向heap申请空间
  2. 考虑线程安全
  3. 内存不足时的应变措施
  4. 考虑因“小内存区块”的释放后可能造成的内存碎片（fragment）问题

考虑到当前目标是要了解std::alloc的功能逻辑与实现结构，所以为了简单明了一些，（2.）线程安全先排除不做考虑。

 

针对（1.）C++有以下两种方式可以配置内存空间。

  1. ::operator new() 与 ::operator delete();
  2. malloc() 与 free()；

所以，SGI分别声明了使用方式（1）的new_alloc类和使用方式（2）的malloc_alloc_template模板类。

1. new_alloc

Cpp代码 复制代码  收藏代码
  1. /** 
  2.    *  A new-based allocator, as required by the standard.  Allocation and 
  3.    *  deallocation forward to global new and delete.  "SGI" style, minus 
  4.    *  reallocate(). 
  5.    *  @endmaint 
  6.    *  (See @link Allocators allocators info @endlink for more.) 
  7.   */  
  8.   class __new_alloc   
  9.   {  
  10.   public:  
  11.     static void*   
  12.     allocate(size_t __n)  
  13.     { return ::operator new(__n); }  
  14.       
  15.     static void   
  16.     deallocate(void* __p, size_t)  
  17.     { ::operator delete(__p); }  
  18.   };  
/**
   *  A new-based allocator, as required by the standard.  Allocation and
   *  deallocation forward to global new and delete.  "SGI" style, minus
   *  reallocate().
   *  @endmaint
   *  (See @link Allocators allocators info @endlink for more.)
  */
  class __new_alloc 
  {
  public:
    static void* 
    allocate(size_t __n)
    { return ::operator new(__n); }
    
    static void 
    deallocate(void* __p, size_t)
    { ::operator delete(__p); }
  };

 2. template<int __inst> class malloc_alloc_template.

Cpp代码 复制代码  收藏代码
  1.    
  2. /** 
  3.    *  @maint 
  4.    *  A malloc-based allocator.  
  5.    */  
  6.   
  7. template <int __inst>  
  8.     class __malloc_alloc_template   
  9.     {  
  10.     private:  
  11.       static void* _S_oom_malloc(size_t);  
  12.       static void* _S_oom_realloc(void*, size_t);  
  13.       static void (* __malloc_alloc_oom_handler)();  
  14.         
  15.     public:  
  16.       static void*   
  17.       allocate(size_t __n)  
  18.       {  
  19.     void* __result = malloc(__n);  
  20.     if (0 == __result) __result = _S_oom_malloc(__n);  
  21.     return __result;  
  22.       }  
  23.   
  24.       static void   
  25.       deallocate(void* __p, size_t /* __n */)  
  26.       { free(__p); }  
  27.   
  28.       static void*   
  29.       reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)  
  30.       {  
  31.     void* __result = realloc(__p, __new_sz);  
  32.     if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);  
  33.     return __result;  
  34.       }  
  35.         
  36.       static void (* __set_malloc_handler(void (*__f)()))()  
  37.       {  
  38.     void (* __old)() = __malloc_alloc_oom_handler;  
  39.     __malloc_alloc_oom_handler = __f;  
  40.     return(__old);  
  41.       }  
  42.     };  
 
/**
   *  @maint
   *  A malloc-based allocator. 
   */

template <int __inst>
    class __malloc_alloc_template 
    {
    private:
      static void* _S_oom_malloc(size_t);
      static void* _S_oom_realloc(void*, size_t);
      static void (* __malloc_alloc_oom_handler)();
      
    public:
      static void* 
      allocate(size_t __n)
      {
	void* __result = malloc(__n);
	if (0 == __result) __result = _S_oom_malloc(__n);
	return __result;
      }

      static void 
      deallocate(void* __p, size_t /* __n */)
      { free(__p); }

      static void* 
      reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
      {
	void* __result = realloc(__p, __new_sz);
	if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);
	return __result;
      }
      
      static void (* __set_malloc_handler(void (*__f)()))()
      {
	void (* __old)() = __malloc_alloc_oom_handler;
	__malloc_alloc_oom_handler = __f;
	return(__old);
      }
    };

针对内存碎片的考虑，SGI设计了双层内存配置器，一级配置器就是上述定义两个类中的一个（取决于系统是否定义了宏USE_MALLOC，如果定义了那么使用malloc_alloc_template，否则使用new_alloc。 二级配置器，逻辑上是一个内存池。如果申请的内存大于128字节的话，那么这样申请由一级配置器处理。只有小于128字节的请求会有二级配置器处理。

 

二级内存配置器（memory pool）的数据结构采用的是freelist的数组，其实这个数据结构实际上就是一个邻接表（表示‘图’的数据结构之一），只是组成数据结构的数据类型所表示的实际意义发生了一些变化。

 

数组的长度是16（128÷8=16），每个数组元素指向一个freelist头节点，所以memory pool实际上就是16个freelists。每个freelist是一个单链表，单链表中的每个结点代表固定字节数的内存块。比如第一个freelist（数组的头元素指向的freelist），表示由表示容量为8字节的内存块结点组成的单链表。那么按照数组顺序，依次代表的是16，24，32，40，48，56，64，72，80，88，96，104，112，120，128字节的freelist。freelist的节点数据类型是一个union，如下声明。

Cpp代码 复制代码  收藏代码
  1. union obj {  
  2.     union obj *free_list_link;  
  3.     char client_data[1];  
  4. };   
union obj {
    union obj *free_list_link;
    char client_data[1];
};

union数据类型具有多面性，按照上述的声明，自然具有两面性了。当节点所代表的内存块属于memory pool中的空闲内存块时，就是free_list_link，指向下一个内存块（像单链表一样）；当节点所代表的内存块已经分配给用户时，就是client_data啦。

 

memory pool还有两个指针（s_start_free 和 s_end_free) 用于计算空闲内存块的大小，还有size_t的变量heap_size用于记录当前memory pool总容量。memory pool可提供的操作主要是如何根据实际内存请求从memory pool中拨出内存(s_chunk_alloc(size_t size, int& nobjs); )，以及根据内存释放请求归还内存块到memory pool中。

 

s_chunk_alloc函数是二级内存配置器的核心函数，因为二级配置器default_alloc_template的allocate接口实现都是高度依赖此函数的实现。s_chunk_alloc也是default_alloc_template的业务逻辑核心。

 

Cpp代码 复制代码  收藏代码
  1. // We allocate memory in large chunks in order to avoid fragmenting the  
  2. // malloc heap (or whatever __mem_interface is using) too much.  We assume  
  3. // that __size is properly aligned. （内存对齐） We hold the allocation lock.  
  4.   
  5.   template<bool __threads, int __inst>  
  6.   char*  
  7.   __default_alloc_template<__threads, __inst>::_S_chunk_alloc(size_t __size,   
  8.                         int& __nobjs)  
  9.   {  
  10.      char* __result; // 预返回的内存块儿首址  
  11.      size_t __total_bytes = __size * __nobjs;   
  12.       
  13.      /* 预分配的内存块总大小，通常情况下nojbs的大小为20, 
  14.       * nobjs的大小由s_refill函数传进。 
  15.       */   
  16.   
  17.     size_t __bytes_left = _S_end_free - _S_start_free;   
  18.     //memory pool剩余内存块大小  
  19.       
  20.     if (__bytes_left >= __total_bytes)    
  21.     /* I: 如果memory pool剩余内存块完全满足需求量 */  
  22.     {  
  23.          __result = _S_start_free;   
  24.          //则将剩余内存块儿的首地址作为结果返回  
  25.          _S_start_free += __total_bytes;   
  26.          //将剩余内存块儿的首地址变为增加需求量之后的地址  
  27.          return(__result);   
  28.     }   
  29.     else if (__bytes_left >= __size)   
  30.     /* II:如果剩余内存空间不足需求量，但是足够供应一个size大小的内存块 */  
  31.     {  
  32.          __nobjs = (int)(__bytes_left/__size);   
  33.          //重新计算nobjs  
  34.          __total_bytes = __size * __nobjs;   
  35.          //改变整体预分配内存的大小  
  36.          __result = _S_start_free;   
  37.         // 返回分配的内存地址为当前剩余内存的首址  
  38.          _S_start_free += __total_bytes;   
  39.         //改变剩余内存的首址为增加了分配内存块后的地址  
  40.         return(__result);  
  41.      }   
  42.     else   
  43.     /* III：memory pool剩余的空间连一个区块的大小也无法提供 */  
  44.     {  
  45.           size_t __bytes_to_get =   
  46.           2 * __total_bytes + _S_round_up(_S_heap_size >> 4);  
  47.    /* 扩大需要量， 新需求量是原需求量的二倍与现有内存池大小的四分之一之和 */  
  48.           if (__bytes_left > 0)   
  49.           /* 如果内存池还有残余的零头内存，处理零头内存 */  
  50.          {  
  51.               _Obj* volatile* __my_free_list =  
  52.               _S_free_list + _S_freelist_index(__bytes_left);   
  53.               //寻找监管残余内存的freelist  
  54.        
  55.               ((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;   
  56.                         
  57.               *__my_free_list = (_Obj*)_S_start_free;   
  58.               /* 归还那些因不足实际需求大小的内存块到监管的freelist中 */  
  59.            }  
  60.   
  61.          _S_start_free = (char*) __mem_interface::allocate(__bytes_to_get);   
  62.          // 请求一级内存配置器分配空间  
  63.          if (0 == _S_start_free)   
  64.         //如果一级配置器分配失败  
  65.         {  
  66.             size_t __i;  
  67.             _Obj* volatile* __my_free_list;  
  68.             _Obj* __p;  
  69.             __i = __size;  
  70.               
  71.             for (; __i <= (size_t) _MAX_BYTES; __i += (size_t) _ALIGN)   
  72.            {  
  73.                 __my_free_list = _S_free_list + _S_freelist_index(__i);  
  74.                 __p = *__my_free_list;  
  75.                 if (0 != __p)   
  76.                {  
  77.                     *__my_free_list = __p -> _M_free_list_link;  
  78.   
  79.                     /* 以下三行比较巧妙，__bytes_left = __i;  
  80.                      * 通过递归调用s_chunk_alloc(size， nobjs)后走II分支 
  81.                      * 找到freelist中未必使用的内存区块，且这个区块足以大于client的实际需求。 
  82.                      */   
  83.                     _S_start_free = (char*)__p;    
  84.                     _S_end_free = _S_start_free + __i;  
  85.                     return(_S_chunk_alloc(__size, __nobjs));  
  86.                 }  
  87.             }  
  88.              
  89.            /*以上for循环顺次查找每个freelist，看是否还有freelist监管的内存区块未被使用且足够大*/  
  90.             _S_end_free = 0;  
  91.             _S_start_free = (char*)__mem_interface::allocate(__bytes_to_get);   
  92.            /*上述尝试若失败，通过一级配置器抛出bad_alloc异常 */    
  93.          }  
  94.         _S_heap_size += __bytes_to_get;   
  95.         //修改memory pool的总容量  
  96.         _S_end_free = _S_start_free + __bytes_to_get;   
  97.         //修改内存池剩余空间大小  
  98.         return(_S_chunk_alloc(__size, __nobjs));   
  99.          /* 在一级内存分配器分配了申请的内存后， 
  100.           * 递归调用s_chunk_alloc后通过I分支处理分配内存。 
  101.           */  
  102.         }  
  103.    }  
  // We allocate memory in large chunks in order to avoid fragmenting the
  // malloc heap (or whatever __mem_interface is using) too much.  We assume
  // that __size is properly aligned. （内存对齐） We hold the allocation lock.

    template<bool __threads, int __inst>
    char*
    __default_alloc_template<__threads, __inst>::_S_chunk_alloc(size_t __size, 
								int& __nobjs)
    {
       char* __result; // 预返回的内存块儿首址
       size_t __total_bytes = __size * __nobjs; 
      
       /* 预分配的内存块总大小，通常情况下nojbs的大小为20,
        * nobjs的大小由s_refill函数传进。
        */ 

      size_t __bytes_left = _S_end_free - _S_start_free; 
      //memory pool剩余内存块大小
      
      if (__bytes_left >= __total_bytes)  
      /* I: 如果memory pool剩余内存块完全满足需求量 */
      {
           __result = _S_start_free; 
           //则将剩余内存块儿的首地址作为结果返回
           _S_start_free += __total_bytes; 
           //将剩余内存块儿的首地址变为增加需求量之后的地址
           return(__result); 
      } 
      else if (__bytes_left >= __size) 
      /* II:如果剩余内存空间不足需求量，但是足够供应一个size大小的内存块 */
      {
           __nobjs = (int)(__bytes_left/__size); 
           //重新计算nobjs
           __total_bytes = __size * __nobjs; 
           //改变整体预分配内存的大小
           __result = _S_start_free; 
          // 返回分配的内存地址为当前剩余内存的首址
           _S_start_free += __total_bytes; 
          //改变剩余内存的首址为增加了分配内存块后的地址
          return(__result);
       } 
      else 
      /* III：memory pool剩余的空间连一个区块的大小也无法提供 */
      {
            size_t __bytes_to_get = 
            2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
	    /* 扩大需要量， 新需求量是原需求量的二倍与现有内存池大小的四分之一之和 */
            if (__bytes_left > 0) 
            /* 如果内存池还有残余的零头内存，处理零头内存 */
           {
                _Obj* volatile* __my_free_list =
                _S_free_list + _S_freelist_index(__bytes_left); 
                //寻找监管残余内存的freelist
	      
                ((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list; 
                	      
                *__my_free_list = (_Obj*)_S_start_free; 
                /* 归还那些因不足实际需求大小的内存块到监管的freelist中 */
             }

           _S_start_free = (char*) __mem_interface::allocate(__bytes_to_get); 
           // 请求一级内存配置器分配空间
           if (0 == _S_start_free) 
          //如果一级配置器分配失败
          {
              size_t __i;
              _Obj* volatile* __my_free_list;
              _Obj* __p;
              __i = __size;
              
              for (; __i <= (size_t) _MAX_BYTES; __i += (size_t) _ALIGN) 
             {
                  __my_free_list = _S_free_list + _S_freelist_index(__i);
                  __p = *__my_free_list;
                  if (0 != __p) 
                 {
                      *__my_free_list = __p -> _M_free_list_link;

                      /* 以下三行比较巧妙，__bytes_left = __i; 
                       * 通过递归调用s_chunk_alloc(size， nobjs)后走II分支
                       * 找到freelist中未必使用的内存区块，且这个区块足以大于client的实际需求。
                       */ 
                      _S_start_free = (char*)__p;  
                      _S_end_free = _S_start_free + __i;
                      return(_S_chunk_alloc(__size, __nobjs));
                  }
              }
             
             /*以上for循环顺次查找每个freelist，看是否还有freelist监管的内存区块未被使用且足够大*/
              _S_end_free = 0;
              _S_start_free = (char*)__mem_interface::allocate(__bytes_to_get); 
             /*上述尝试若失败，通过一级配置器抛出bad_alloc异常 */  
           }
          _S_heap_size += __bytes_to_get; 
          //修改memory pool的总容量
          _S_end_free = _S_start_free + __bytes_to_get; 
          //修改内存池剩余空间大小
          return(_S_chunk_alloc(__size, __nobjs)); 
           /* 在一级内存分配器分配了申请的内存后，
            * 递归调用s_chunk_alloc后通过I分支处理分配内存。
            */
          }
     }

 

根据上述代码，s_chunk_alloc的主要逻辑实际上是处理三种情况：

I:    内存池剩余空间足以满足内存的分配请求（注意此时的接收到的内存分配请求是client需求量的20倍）；

       处理方法：直接从剩余空间中拨出需求量大小的内存区块。

II:   内存池剩余空间不足满足需求量，但是大于一个区块（client实际需求量）；

       处理方法：缩小需求量至内存池剩余空间按照client实际需求量的最大倍数，然后按照新需求量分配内存块返回；

III:  内存池剩余空间既不能满足需求量，也不能满足实际client需求量；

       处理方法：

  1. 先调整内存池中零头的内存块，使其归为到对应的freelist中。
  2. 请求一级内存配置器分配扩大后需求量。注意，扩大后的需求量是原始需求量的二倍与内存池大小的四分之一的和那么大。
  3. 如果一级内存配置器分配新需求量失败，试图在已分配但未使用的内存块（freelist）中寻找足以大于实际client需求的内存分配内存块返回给客户。
  4. 如果步骤3失败，再向一级内存配置器请求帮助，如果帮助未果则利用一级内存配置器抛出异常bad_alloc。
  5. 如果一级内存配置器分配请求成功后，递归调用自己走I情况分配内存块。

在了解上述memory pool分配内存块的基本逻辑后，还需要进一步了解s_refill函数。因为二级内存配置器的allocate函数实现是s_refill与s_chunk_alloc两个实现的协作实现。

 

s_refill模板函数的实现

Cpp代码 复制代码  收藏代码
  1.  // Returns an object of size __n, and optionally adds to "size  
  2.  // __n"'s free list.  We assume that __n is properly aligned.  We  
  3.  // hold the allocation lock.  
  4.    
  5. template<bool __threads, int __inst>  
  6.    void*  
  7.    __default_alloc_template<__threads, __inst>::_S_refill(size_t __n)  
  8.   {  
  9.      int __nobjs = 20;   
  10.      //默认20个，实际client需求的20倍  
  11.      char* __chunk = _S_chunk_alloc(__n, __nobjs);  
  12.      //请求memory pool分配内存块，实际需求的20倍  
  13.      _Obj* volatile* __my_free_list;  
  14.      _Obj* __result;  
  15.      _Obj* __current_obj;  
  16.      _Obj* __next_obj;  
  17.      int __i;  
  18.        
  19.     if (1 == __nobjs) return(__chunk);  
  20.      
  21.     __my_free_list = _S_free_list + _S_freelist_index(__n);  
  22.        
  23.     __result = (_Obj*)__chunk;   
  24.     //将返回给客户20块内存区块的第一块地址  
  25.    *__my_free_list = __next_obj = (_Obj*)(__chunk + __n);  
  26.     //修改监管freelist的首地址为第一个空闲内存块的地址  
  27.   
  28.    for (__i = 1; ; __i++) {  
  29.        __current_obj = __next_obj;  
  30.        __next_obj = (_Obj*)((char*)__next_obj + __n);  
  31.        if (__nobjs - 1 == __i) {  
  32.          __current_obj -> _M_free_list_link = 0;  
  33.          break;  
  34.        } else {  
  35.          __current_obj -> _M_free_list_link = __next_obj;  
  36.        }  
  37.    }  
  38.   
  39.    //上述for循环，是将freelist中的各结点串接起来。  
  40.   
  41.     return(__result);  
  42. }  
  // Returns an object of size __n, and optionally adds to "size
  // __n"'s free list.  We assume that __n is properly aligned.  We
  // hold the allocation lock.
  
 template<bool __threads, int __inst>
    void*
    __default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
   {
      int __nobjs = 20; 
      //默认20个，实际client需求的20倍
      char* __chunk = _S_chunk_alloc(__n, __nobjs);
      //请求memory pool分配内存块，实际需求的20倍
      _Obj* volatile* __my_free_list;
      _Obj* __result;
      _Obj* __current_obj;
      _Obj* __next_obj;
      int __i;
      
     if (1 == __nobjs) return(__chunk);
    
     __my_free_list = _S_free_list + _S_freelist_index(__n);
      
     __result = (_Obj*)__chunk; 
     //将返回给客户20块内存区块的第一块地址
    *__my_free_list = __next_obj = (_Obj*)(__chunk + __n);
     //修改监管freelist的首地址为第一个空闲内存块的地址

    for (__i = 1; ; __i++) {
        __current_obj = __next_obj;
        __next_obj = (_Obj*)((char*)__next_obj + __n);
        if (__nobjs - 1 == __i) {
          __current_obj -> _M_free_list_link = 0;
          break;
        } else {
          __current_obj -> _M_free_list_link = __next_obj;
        }
    }

    //上述for循环，是将freelist中的各结点串接起来。

     return(__result);
 }

  最后我们看看二级内存配置器是如何完成内存配置服务的。

Cpp代码 复制代码  收藏代码
  1.  static void*   
  2.     allocate(size_t __n)  
  3.     {  
  4.       void* __ret = 0;  
  5.         
  6.       if (__n > (size_t) _MAX_BYTES)   
  7.       // 如果请求大于128字节，由一级内存配置器分配内存  
  8.     __ret = __mem_interface::allocate(__n);  
  9.       else   
  10.       // 当内存请求小于等于128字节时  
  11.     {  
  12.            _Obj* volatile* __my_free_list = _S_free_list   
  13.              + _S_freelist_index(__n);  
  14.       //定位监管的freelist  
  15.   
  16.           _Obj* __restrict__ __result = *__my_free_list;  
  17.           if (__result == 0)  
  18.           //如果freelist是空的，则通过调用s_refill分配freelist  
  19.         __ret = _S_refill(_S_round_up(__n));  
  20.       else   
  21.           //如果freelist有空闲内存块，则返回一个空闲块给客户  
  22.           //同时监管freelist的头指针后移一个空闲块  
  23.           {  
  24.               *__my_free_list = __result -> _M_free_list_link;  
  25.               __ret = __result;  
  26.           }  
  27.       }  
  28.       return __ret;  
  29. };  
 static void* 
    allocate(size_t __n)
    {
      void* __ret = 0;
      
      if (__n > (size_t) _MAX_BYTES) 
      // 如果请求大于128字节，由一级内存配置器分配内存
	__ret = __mem_interface::allocate(__n);
      else 
      // 当内存请求小于等于128字节时
	{
           _Obj* volatile* __my_free_list = _S_free_list 
             + _S_freelist_index(__n);
	  //定位监管的freelist

          _Obj* __restrict__ __result = *__my_free_list;
          if (__result == 0)
          //如果freelist是空的，则通过调用s_refill分配freelist
	    __ret = _S_refill(_S_round_up(__n));
	  else 
          //如果freelist有空闲内存块，则返回一个空闲块给客户
          //同时监管freelist的头指针后移一个空闲块
          {
              *__my_free_list = __result -> _M_free_list_link;
              __ret = __result;
          }
      }
      return __ret;
};

 

下面举个例子，假设程序一开始，二级内存配置器相继收到如下内存请求：

 256字节， 32字节， 32字节，64字节，48字节， 48字节；

1. 256字节：因为其大小大于128字节，则由一级内存配置器直接分配大块内存256字节给客户。

2. 32字节：小于128字节，二级配置器接管请求；找到监管freelist是第4个，数组下标#3， 发现freelist是空；则进一步调用s_refill申请内存；此时s_refill（32）接收到请求后，调用s_chunk_alloc(32, 20)先完成内存池中第四个freelist的分配；

      2.1. s_chunk_alloc(32,20)被调用后，内存池是空的，于是直接请求一级内存配置器分配640字节的内存块给内存池。

      2.2 一级内存配置器完成分配后，返回给内存池，内存池将此640字节大小的内存块首地址记录到s_start_free指针，同时修改内存池大小，并记录空闲内存块的尾指到s_end_free指针。

      2.3 递归调用s_chunk_alloc(32, 20), 此时内存池的空闲内存块是640字节，大于320字节，所以程序处理流程进入I分支。I分支会将这640字节的内存块分成320字节的两大块，前320字节那块作为结果返回，后320字节作为内存池的空闲内存块，s_start_free的地址修改指向后320字节内存块的首地址。

      2.4 s_refill此时接收到调用s_chunk_alloc(32, 20)返回的结果后，将320字节内存块分成20块，第一个32字节内存块作为客户请求返回，其余的19个32字节内存块依次串接起来作为第4个freelist监管起来。

3. 32字节：小于128字节，二级配置器接管请求；找到监管freelist是第4个，数组下标#3，发现freelist已分配；此时，直接将freelist中的第一个32字节的内存块（余下19个32字节内存块中的第一个，相当于初始分配的20个内存块中的第二个）返回给客户，同时监管的freelist指向余下的18个内存块。

4. 64字节：小于128字节，二级配置器接管请求。定位监管freelist是第8个，数组下标#7，为空。调用s_refill（64）。同样，s_refill调用s_chunk(64, 20);

      4.1. s_chunk_alloc(64, 20)被调用后，内存池的空闲内存块大小是320字节，注意此时需求量是1280字节。

      4.2. 因为320字节小于1280字节，但又大于64字节，所以满足II分支的条件。

      4.3. II分支先在内存池中修改需求量到320字节，nobjs由原来的20变为5. 将空闲的320字节内存块首址作为结果返回，同时内存池已经没有空闲内存块了。

      4.4. 同样，s_refill得到结果后，将320字节的内存块分成5块，第一个64字节内存块作为响应客户的64字节请求返回，而余下的4块串接起来作为第8个freelist监管起来。

5. 48字节：小于128字节，二级配置器接管请求。定位监管freelist是第6个，数组下标#5，为空。调用s_refill(48)。

同样，s_refill调用s_chunk(48,20)。

      5.1. s_chunk_alloc(48,20)被调用后，内存池空闲内存块是0字节，需求量是960字节，实际需求是48字节。

      5.2. 因为空闲内存块是0字节，所以进入分支III。

      5.3. 分支III，请求一级配置器帮助分配1920字节的内存块，但是我们假定现在一级内存配置器分配内存失败。

          5.4.1. 此时，分支III从监管48字节的freelist开始，循环随后每一个freelist，略过第8个freelist之前2个空freelist。

          5.4.2. 第8个freelist不空，将内存池的空闲内存块设置成freelist监管的4个64字节内存块中的第一个，然后递归调用s_chunk_alloc(48, 20);

          5.4.3. 此时内存池空闲内存大小是64字节，走分支II。

          5.4.4. 分支II，重新计算nobjs=1。此64字节的内存块的起始地址将作为结果返回，同时修改内存池空闲内存的起始地址到返回结果偏移48字节的地址。所以此时内存池的空闲地址是64-48=16字节。（注意此16字节就是零碎内存块了，这16字节的空闲内存，只有下次内存请求的时候会被归还。）

      5.4. s_refill得到结果后，直接将结果再返回给客户。

6. 48字节： 小于128字节，二级配置器接管请求。定位监管freelist是第6个，数组下标#5，为空。调用s_refill(48)。

同样，s_refill调用s_chunk(48,20)。

      6.1. s_chunk_alloc(48,20)被调用后，内存池空闲内存是16字节，需求量是960字节，实际需求是48字节。

      6.2. 所以走分支III。

      6.3. 分支III。

         6.3.1. 先将16字节的空闲内存归并到第2个freelist中。（相当于将空闲内存快作为freelist的头元素插入）

         6.3.2. 然后请求一级配置器帮助分配1920字节的内存块，但是仍然无功而返

         6.3.3. 从第6个freelist开始遍历，略过空freelist，直至第8个freelist。

         6.3.4. 第8个freelist不空，将内存池的空闲内存块设置成freelist监管的3个64字节内存块中的第一个，然后递归调用s_chunk_alloc(48, 20);

         6.3.5. 此时内存池空闲内存大小是64字节，走分支II。

         6.3.6. 分支II，重新计算nobjs=1。此64字节的内存块的起始地址将作为结果返回，同时修改内存池空闲内存的起始地址到返回结果偏移48字节的地址。所以此时内存池的空闲地址是64-48=16字节。

Cpp代码 复制代码  收藏代码
  1. static void   
  2.     deallocate(void* __p, size_t __n)  
  3.     {  
  4.       if (__n > (size_t) _MAX_BYTES)  
  5.     __mem_interface::deallocate(__p, __n);  
  6.       else   
  7.     {  
  8.       _Obj* volatile*  __my_free_list  
  9.         = _S_free_list + _S_freelist_index(__n);  
  10.       _Obj* __q = (_Obj*)__p;  
  11.         
  12.       __q -> _M_free_list_link = *__my_free_list;  
  13.       *__my_free_list = __q;  
  14.     }  
  15.     }  
static void 
    deallocate(void* __p, size_t __n)
    {
      if (__n > (size_t) _MAX_BYTES)
	__mem_interface::deallocate(__p, __n);
      else 
	{
	  _Obj* volatile*  __my_free_list
	    = _S_free_list + _S_freelist_index(__n);
	  _Obj* __q = (_Obj*)__p;
	  
	  __q -> _M_free_list_link = *__my_free_list;
	  *__my_free_list = __q;
	}
    }
 

         6.3.7. s_refill得到结果后，直接将结果再返回给客户。

 

以上便是二级内存配置器的内存分配请求逻辑；下面的deallocate相对来说，就简单至极了。寻找的监管的freelist，然后通过修改指针，归并释放的内存块到监管的freelist即可。注意归还的时候，都是作为freelist的头元素插入到freelist中的。

 

小结：

       感觉freelist的内存分配方式，内存利用率不高。

       不知道通过什么方式可以比较一下std::alloc的执行效率 。

    
分享到：                  
       |       cppcms中的session    
评论
              
发表评论

  您还没有登录,请您登录后再发表评论

        
        
qqsunkist
  • 浏览: 4703 次
  • 性别: Icon_minigender_1
  • 来自: 大连
社区版块
存档分类
最新评论
          
    Logo
    向您推荐>>Eolink开发者社区

    权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

    更多推荐

    深入理解 Mocha 测试框架：从零实现一个 Mocha

    前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

    avatar 云原生

    ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

    企业级ELK Stack构建介绍

    avatar 云原生

    (20200916 Solved)docker-compose up创建容器自动退出

    问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

    avatar 云原生