STL-空间配置器(allocator)

     STL的空间配置器作为STL六大部件的重要组成部分,它总是隐藏在一切组件的背后.它主要负责动态空间的分配、释放等管理工作。整个STL的操作对象(所有的数值)都存放在容器之内,而容器一定需要配置空间以置放资料。而这就是空间配置器(allocator)的职责了.

一.SGI的空间配置器—std::alloc

   STL allocator将内存分配/释放和对象构造/析构区分开来.内存配置操作由alloc::allocate()负责,内存释放由alloc::deallocate()负责;对象构造操作由::construct()负责,对象析构操作由::destroy()负责.

   STL标准表格告诉我们,配置器定义于<memory>中，SGI<memory>内含两个文件:

  #include <stl_alloc.h>  //负责内存空间的配置与释放

  #include <stl_construct.h> //负责对象内容的构造与析构

 

1.构造和析构基本工具:construct()和destroy()

#include <new.h> //欲使用placement new,需先包含此文件



template<class T1,class T2>

inline void construct(T1* p,const T2& value){

    new (p) T1(value); //placement new;调用T1::T1(value);

}



//以下是destroy()第一版本,接受一个指针

template<class T>

inline void destroy(T* pointer){

     pointer->~T();//调用dtor ~T()

}



template<class ForwardIterator>

inline void destroy(ForwardIterator first,ForwardIterator last){

    __destroy(first,last,value_type(first));

}



//判断元素的数值型别(value type)是否有trivial destructor

template <class ForwardIterator,class T>

inline void destroy(ForwardIterator first,ForwardIterator last,T*){

    typedef typename __type_trait<T>::has_trivial_destructor trivial_destructor;

    __destroy_aux(first,last,trivial_destructor());

}



//如果元素的数值型别(value_type)有non-trivial destructor

template <class ForwardIterator>

inline void __destroy_aux(ForwardIterator first,ForwardIterator last,__false_type){

    for(;first<last;first++) destroy(&*first);

}



template <class ForwardIterator>

inline void __destroy_aux(ForwardIterator first,ForwardIterator last,__true_type){}



inline void destroy(char*,char*){}

inline void destroy(wchar_t*,wchar_t*){}

 

 

 

  2.空间的配置与释放

     SGI是以malloc()和free()完成内存的配置与释放.考虑到小型区块所可能造成的内存破碎问题,SGI设计了双层级配置器。第一级配置器直接使用malloc()和free(),第二级配置器则视情况采用不同的策略:当配置区块超过128bytes时,视之为"足够大",便调用第一级配置器;当配置区块小于128bytes时,视之为"过小",为了降低额外负担，便采用memory pool整理方式,而不再求助于第一级配置器。

     无论alloc被定义为第一级或第二级配置器,SGI还为它再包装了一个接口,使配置器的接口更符合STL规格。

template <class T,class Alloc>

class simple_alloc{

public:

      static T* allocate(size_t n){

          return 0==n?0:(T*)Alloc::allocate(n*sizeof(T));

      }

      static T* allocate(void){

          return (T*)Alloc::allocate(sizeof(T));

      }

      static void deallocate(T* p,size_t n){

          if(n!=0) Alloc::deallocate(p,n*sizeof(T));

      }

      

      static void deallocate(T* p){

          Alloc::deallocate(p,sizeof(T));

      }

};

 

其内部四个成员函数其实都是单纯的转调用,调用传递给配置器(可能是第一级也可能是第二级)的成员函数。SGI STL容器全部都是使用这个simple_alloc接口。

  2.1 第一级配置器 __malloc_alloc_template剖析

 

//注意,无"template型别参数",inst完全没有派上用场

template<int inst>

class __malloc_alloc_template{

private:

      //以下都是函数指针,所代表的函数将用来处理内存不足的情况

      //oom:out of memory

      static void* oom_malloc(size_t);

      static void* 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=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) oom_realloc(p,new_sz);

          return result;

      }

      

      //以下仿真C++的set_new_handler()

      static void (*set_malloc_handler(void (*f)()))(){

          void (*old)()=__malloc_alloc_oom_handler;

          __malloc_alloc_oom_handler=f;

          return (old);

      }

};



void (*__malloc_alloc_template<int>::__malloc_alloc_oom_handler)()=0;

    

template<int inst>

void* __malloc_alloc_template<inst>::oom_malloc(size_t n){

    void (*my_malloc_handler)();

    void* result;

    

    for(;;){                     //不断尝试释放、配置、释放、配置...

        my_malloc_handler=_malloc_alloc_oom_handler;

        if(0==my_malloc_handler) {__THROW_BAD_ALLOC;}

        (*my_malloc_handler)();//调用处理例程,企图释放内存

        result=malloc(n);   //再次尝试分配内存

        if(result) return (result);

    }

}



template<int inst>

void* __malloc_alloc_template<inst>::oom_realloc(size_t n){

    void (*my_malloc_handler)();

    void* result;

    

    for(;;){                       //不断尝试释放、分配、释放、分配...

        my_malloc_handler=_malloc_alloc_oom_handler;

        if(0==my_malloc_handler) {__THROW_BAD_ALLOC;}

            (*my_malloc_handler)();//调用处理例程,企图释放内存

        result=realloc(p,n);   //再次尝试分配内存

        if(result) return (result);

    }

}

 

所谓c++ new handler机制是,当系统在内存配置需求无法被满足时，调用一个你指定的函数。也就是说,一旦::operator new无法完成任务,在丢出std::bad_alloc异常状态时,会先调用用户所指定的例程。

 

   2.1 第二级配置器 __default_alloc_template剖析

      SGI第二级配置器的做法是,如果区块足够大，超过128bytes时，就移交第一级配置器处理。当区块小于128bytes时,则以内存池(memory pool)管理：每次配置一大块内存，并维护对应之自由链表(free-list)。下次若再有相同大小的内存需求，就直接从free-list中取出。如果客户端释还小额区块,就由配置器回收到free-list中。为了方便管理,SGI第二级配置器会主动将任何小额区块的内存需求量上调至8的倍数,并维护16个free-list，各自管理大小分别为8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128bytes的区块。

//free-lists的节点结构如下:

  union obj{

       union obj* free_list_link;

       char client_data[1]; //The client sees this

  };

  第二级配置器的部分源码:

//free-lists的节点结构如下:

  union obj{

       union obj* free_list_link;

       char client_data[1]; //The client sees this

  };

  

  enum {__ALIGN=8};//小型区块的上调边界

  enum {__MAX_BYTES=128}; //小型区块的上限

  enum {__NFREELISTS=__MAX_BYTES/__ALIGN}; //free-lists的个数

  

  //以下是第二级配置器

  template <bool threads,int inst>

  class __default_alloc_template{

  private:

        //ROUND_UP()将bytes上调至8的倍数

        static size_t ROUND_UP(size_t bytes){

             return ((bytes)+__ALIGN-1) & ~(__ALIGN-1));

        }

        

  private:

        union obj{  //free-lists的节点构造

             union obj* free_list_link;

             char client_data[1];

        };

        

  private:

       //16个free-lists

       static obj* volatile free_list[__NFREELISTS];

       //以下函数根据区块大小,决定使用第n号free-lists.n从1开始

       static size_t FREELIST_INDEX(size_t bytes){

             return ((bytes)+__ALIGN-1)/__ALIGN-1);

       }

       

       //返回一个大小为n的对象，并可能加入大小为n的其他区块到free list

       static void* refill(size_t n);

       //配置一大块空间,可容纳nobjs个大小为"size"的区块

       static char* chunk_alloc(size_t size,int &nobjs);

       

       //chunk allocation state

       static char* start_free;//内存池起始位置

       static char* end_free;

       static size_t heap_size;

       

  public:

        static void* allocate(size_t n){}

        static void deallocate(void* p,size_t n){}

        static void* reallocate(void* p,size_t old_sz,size_t new_sz);

  };

  

  //以下是static data memeber的定义与处置设定

  template <bool threads,int inst>

  char* __default_alloc_template<threads,inst>::start_free=0;

      

  template <bool threads,int inst>

  char* __default_alloc_template<threads,inst>::end_free=0;

      

  template <bool threads,int inst>

  size_t __default_alloc_template<threads,inst>::heap_size=0;