SGI的内存管理

1. SGI中的内存管理

在SGI中， 其内存分配把这两步独立出了两个函数：allocate 申请内存，construct 调用构造函数，分别在

2.构造和析构的工具

在stl_construct.h中

//第一个版本destory接受一个指针，然后调用析构函数
template <class T>
inline void destroy(T* pointer) {
    pointer->~T();
}

//构造函数
template <class T1, class T2>
inline void construct(T1* p, const T2& value) {
  new (p) T1(value);
}

//第二个版本的destory,接收两个迭代器，并根据元素的值的类型来调用析构函数，为__false_type,调用析构，为__true_type,直接不管。
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, ForwardIterator, __true_type) {}
template <class ForwardIterator, class T>
inline void __destroy(ForwardIterator first, ForwardIterator last, T*) {
  typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
  __destroy_aux(first, last, trivial_destructor());
}
template <class ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last) {
  __destroy(first, last, value_type(first));
}
//特化版本的destroy函数。
inline void destroy(char*, char*) {}
inline void destroy(wchar_t*, wchar_t*) {}

3.空间配置与释放

考虑到小型区块可能造成的内存破碎问题，SGI设计了双层级配置器。第一级配置器直接使用malloc()和free(),第二级配置器对具体问题使用不同的策略。

3.1 第一级配置器

class __malloc_alloc_template {
private:
//以下函数处理内存不足的情况
//oom - out of memory
static void *oom_malloc(size_t);
static void *oom_realloc(void *, size_t);

public:
static void * allocate(size_t n)
{
    void *result = malloc(n);  //第一级配置器直接调用malloc
    if (0 == result) result = oom_malloc(n);//无法满足需求调用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 = oom_realloc(p, new_sz);
    return result;
}
//参数为void f(),返回值也为void f(),用于自己指定oom handle
static void (* set_malloc_handler(void (*f)()))()
{
    void (* old)() = __malloc_alloc_oom_handler;
    __malloc_alloc_oom_handler = f;
    return(old);
}

};

void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;//初始值为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(void *p, 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);
    }
}

3.2 二级配置器

template <bool threads, int inst>
class __default_alloc_template {
private:
  // Really we should use static const int x = N
  // instead of enum { x = N }, but few compilers accept the former.
    enum {__ALIGN = 8};     //小型区块的上调边界
    enum {__MAX_BYTES = 128};//小型区块的上限
    enum {__NFREELISTS = __MAX_BYTES/__ALIGN};//free_list个数
  static size_t ROUND_UP(size_t bytes) {
        return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));//上调的__ALIGN的倍数
  }
__PRIVATE:
  //obj是节点。
  union obj {
        union obj * free_list_link;
        char client_data[1];    /* The client sees this.        */
  };
private:
    static obj * __VOLATILE free_list[];
    //获得节点的序号，0开始
  static  size_t FREELIST_INDEX(size_t bytes) {
        return (((bytes) + __ALIGN-1)/__ALIGN - 1);
  }
  // Returns an object of size n, and optionally adds to size n free list.
  static void *refill(size_t n);
  // Allocates a chunk for nobjs of size "size".  nobjs may be reduced
  // if it is inconvenient to allocate the requested number.
  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:
  /* n must be > 0      */
    //yk:内存分配
  static void * allocate(size_t n)
  {  //后面介绍
  };
  /* p may not be 0 */
  //yk : free memory
  static void deallocate(void *p, size_t n)
  {//后面介绍
  }
  // reallocate memory
  static void * reallocate(void *p, size_t old_sz, size_t new_sz);
} ;
typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
typedef __default_alloc_template<false, 0> single_client_alloc;
//成员函数的初始化
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;
template <bool threads, int inst>
__default_alloc_template<threads, inst>::obj * __VOLATILE
__default_alloc_template<threads, inst> ::free_list[
# ifdef __SUNPRO_CC
    __NFREELISTS
# else
    __default_alloc_template<threads, inst>::__NFREELISTS
# endif
] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
// The 16 zeros are necessary to make version 4.1 of the SunPro
// compiler happy.  Otherwise it appears to allocate too little
// space for the array.

我们最关心的有三点：1. 内存池的创建。2.内存的分配。 3. 内存的释放。

1、SGI内存池的结构

内部的结构体为：

union obj {
        union obj * free_list_link;
        char client_data[1];    /* The client sees this.        */
  };

一个free_list指针指向一个128byte的空间，每个空间根据管理的大小（8,16,32……128），有不同个数的节点数目。为了节省指针的空间， 每个节点为一个union.其中的free_list_link指向下一个空的节点,client_data为柔性数组，大小为当前空间中每个区块的大小。

static obj * __VOLATILE free_list[];

为一个free_list数组，有16个free_list,每个free_list也为一个obj,它有一个指针，指向自己管理的空间第一个节点，它的free_list_link指向第一个自己管理的大小的空间。比如说，#11号区域，刚开始的时候，它是管理一个96byte的空间的，它自己的占用的空间存放的是这个96byte的起始地址，它的free_list_link也是指向这个地址，如果这个空间被别人申请了，那么，申请的时候就会让它指向下一个96byte的空间。

2、内存分配

内存分配的源码如下：

  static void * allocate(size_t n)
  {
    obj * __VOLATILE * my_free_list;
    obj * __RESTRICT result;
    if (n > (size_t) __MAX_BYTES) {//大于128byte，直接调用一级配置器
        return(malloc_alloc::allocate(n));
    }
    my_free_list = free_list + FREELIST_INDEX(n);//找到合适的序号的地址
    result = *my_free_list;
    if (result == 0) {//没有找到合适的，准备重新填充
        void *r = refill(ROUND_UP(n));
        return r;
    }
    *my_free_list = result -> free_list_link;//重新调整free_list
    return (result);
  };

3、空间释放

 static void deallocate(void *p, size_t n)
  {
    obj *q = (obj *)p;
    obj * __VOLATILE * my_free_list;
    if (n > (size_t) __MAX_BYTES) {//大于128byte,调用第一级配置器
        malloc_alloc::deallocate(p, n);
        return;
    }
    //否则回收
    my_free_list = free_list + FREELIST_INDEX(n);

    q -> free_list_link = *my_free_list;
    *my_free_list = q;
  }

4、重新填充 free_list，

当free_list中没有可用区块了，就refill()，准备为free_list重新填充空间。新的空间将取自内存池，一般取20个新节点，如果空间不足的话，可能取不到。

template <bool threads, int inst>
void* __default_alloc_template<threads, inst>::refill(size_t n)
{
    int nobjs = 20;//默认20个区块
    char * chunk = chunk_alloc(n, nobjs);//调用chunk_alloc
    obj * __VOLATILE * my_free_list;
    obj * result;
    obj * current_obj, * next_obj;
    int i;
    if (1 == nobjs) return(chunk);//只申请到一个区块，也是惨，直接返回这个区块
    my_free_list = free_list + FREELIST_INDEX(n);//申请的比较多的话，my_free_list现在指向n大小的free_list
    /* Build free list in chunk */
    //以下在申请的空间创建free_list
      result = (obj *)chunk;//保存返回值
      *my_free_list = next_obj = (obj *)(chunk + n);//这是第一个
      for (i = 1; ; i++) {//从第一个开始，第0个给客户端了。
        current_obj = next_obj;
        next_obj = (obj *)((char *)next_obj + n);
        if (nobjs - 1 == i) {//没有了
            current_obj -> free_list_link = 0;
            break;
        } else {//如果还有，指向下一个obj
            current_obj -> free_list_link = next_obj;
        }
      }
    return(result);
}

5、内存池

template <bool threads, int inst>
char*
__default_alloc_template<threads, inst>::chunk_alloc(size_t size, int& nobjs)
{//开始申请空间
    char * result;
    size_t total_bytes = size * nobjs;//想要申请的空间，想想就好
    size_t bytes_left = end_free - start_free;//剩余的空间
    if (bytes_left >= total_bytes) {//剩余的空间比较多，直接给他就好了
        result = start_free;
        start_free += total_bytes;
        return(result);
    } else if (bytes_left >= size) {//如果剩余空间不多，但还是至少有一个size的大小
        nobjs = bytes_left/size;    //就尽量分给他
        total_bytes = size * nobjs;
        result = start_free;
        start_free += total_bytes;
        return(result);
    } else {//实在没有办法，只能去malloc了
        size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
        // Try to make use of the left-over piece.
        if (bytes_left > 0) {//剩余的空间，直接放到free_list中。因为申请的时候是按8的倍数来申请
            //这里不会有小区块的问题
            obj * __VOLATILE * my_free_list =
                        free_list + FREELIST_INDEX(bytes_left);
            ((obj *)start_free) -> free_list_link = *my_free_list;
            *my_free_list = (obj *)start_free;
        }
        //开始申请了
        start_free = (char *)malloc(bytes_to_get);
        if (0 == start_free) {//oh,没有申请成功
            int i;
            obj * __VOLATILE * my_free_list, *p;
            // Try to make do with what we have.  That can‘t
            // hurt.  We do not try smaller requests, since that tends
            // to result in disaster on multi-process machines.
            //从自己有的资源里面去找
            for (i = size; i <= __MAX_BYTES; i += __ALIGN) {
                my_free_list = free_list + FREELIST_INDEX(i);
                p = *my_free_list;
                if (0 != p) {//这是找到了
                    *my_free_list = p -> free_list_link;
                    start_free = (char *)p;
                    end_free = start_free + i;
                    return(chunk_alloc(size, nobjs));//调整一下
                    // Any leftover piece will eventually make it to the
                    // right free list.
                }
            }
        end_free = 0;   // In case of exception.实在没有空间了，调用一级配置器，看看oom机制
            start_free = (char *)malloc_alloc::allocate(bytes_to_get);
            // This should either throw an
            // exception or remedy the situation.  Thus we assume it
            // succeeded.
        }
        //这是申请成功的，调用自己，修正nobjs
        heap_size += bytes_to_get;
        end_free = start_free + bytes_to_get;
        return(chunk_alloc(size, nobjs));
    }
}

举个例子：

1.调用chunk_allock(32,20):malloc分配40个32byte区域，第一块个客户端，19块给free_list[3],剩余20块给内存池

2.调用chunk_allock(64,20):free_list[7]为空，那么向内存池请求，内存池只有10个，就把这10个给他，第一个交给客户端，剩余9个给free_list[7]维护

3（自己加的）.调用chunk_allock(32, 20):free_list[6]为空，内存池啥也没有，如果malloc失败，在自己free_list[7]找到一块，把free_list[7]的一个拿出来释放到内存池，然后调用自己，这里，内存池现在有64byte，因此可以申请两个32bytes,一个给客户端，一个由free_list[6]维护

4.接下来调用chunk_alloc(96,20):free_list[11]为空，向内存池请求，内存池也没有，只能调用malloc(),40+n个96bytes区块,d第一个给客户端，19个给free_list[11],剩余20+n给内存池