zoukankan      html  css  js  c++  java
  • STL——空间的配置和释放std::alloc(第一级配置器和第二级配置器)

    1 空间的配置和释放,std::alloc

    对象构造前的空间配置和对象析构后的空间释放,由<stl_alloc.h>负责,SGI对此的设计哲学如下:

    • 向system heap要求空间
    • 考虑多线程状态
    • 考虑内存不足时的应变措施
    • 考虑过多“小型区块”可能造成的内存碎片问题

    C++的内存配置基本操作是::operator new(),内存释放基本操作是::operator delete().这两个全局函数相当于C的malloc()和free()函数。是的,正是如此,SGI正是以malloc()和free()完成内存的配置和释放。

    考虑到小型区别所可能造成的内存碎片问题。SGI设计了双层配置器,第一级配置器直接使用malloc()和free(),第二级配置器则视情况采用不同的策略;当配置区块超过128bytes时,视之为“足够大”,便调用第一级配置器;当配置区块小于128bytes时,视之为“过小”,为了降低额外负担,便采用复杂的memory pool整理方式,而不再求助于第一级配置器。整个设计究竟是开放第一级配置器或是同时开放第二级配置器,取决于_USE_MALLOC是否被定义:

    # ifdef __USE_MALLOC 
    ... 
    typedef __malloc_alloc_template<0> malloc_alloc; <span style="font-family:KaiTi_GB2312;">//令 alloc为第一级配置器</span>
    typedef malloc_alloc alloc; 
    # else 
    ... 
    //令 alloc 为第二级配置器 
    typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc; 
    #endif /* ! __USE_MALLOC */ 
    

    其中__malloc_alloc_template就是第一级配置器,__default_alloc_template就是第二级配置器。

    无论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 (0 != n) Alloc::deallocate(p, n * sizeof (T)); }
        static void deallocate(T *p)
                    { Alloc::deallocate(p, sizeof (T)); }
    };
    

    其内部四个成员函数其实都是弹单纯的转调用,调用传递给配置器(可能是第一级也可能是第二级)的成员函数。

    一、二级配置器的关系如下:

    图 第一级配置器和第二级配置器

    第一级和第二级配置器的包装接口和运用方式如下:

    2 第一级配置器__malloc_alloc_template剖析

    首先我们观察第一级配置器:

    #if 0 
    #   include <new> 
    #   define  __THROW_BAD_ALLOC throw bad_alloc 
    #elif !defined(__THROW_BAD_ALLOC) 
    #   include <iostream.h> 
    #   define  __THROW_BAD_ALLOC cerr << "out of memory" << endl; exit(1) 
    #endif 
     
    // malloc-based allocator. 通常比稍后介绍的 default alloc 速度慢, 
    //一般而言是 thread-safe,并且对于空间的运用比较高效(efficient)。 
    //以下是第一级配置器。 
    //注意,无「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);//第一级配置器直接使用 malloc() 
        // 以下,无法满足需求时,改用 oom_malloc() 
        if (0 == result) result = oom_malloc(n); 
        return  result; 
    } 
    static void deallocate(void *p, size_t /* n */) 
    { 
    free(p); //第一级配置器直接使用 free() 
    } 
     
    static void * reallocate(void *p, size_t /* old_sz */, size_t new_sz) 
    { 
        void  *  result  =realloc(p, new_sz);//第一级配置器直接使用 rea
        // 以下,无法满足需求时,改用 oom_realloc() 
        if (0 == result) result = oom_realloc(p, new_sz); 
        return  result; 
    } 
     
    //以下模拟 C++的 set_new_handler(). 换句话说,你可以透过它, 
    //指定你自己的 out-of-memory handler 
    static void (* set_malloc_handler(void (*f)()))() 
    { 
        void  (*  old)()  =  __malloc_alloc_oom_handler; 
    __malloc_alloc_oom_handler = f; 
        return(old); 
    } 
    }; 
     
    // malloc_alloc out-of-memory handling 
    //初值为 0。有待客端设定。 
    template <int inst> 
    void (* __malloc_alloc_template<inst>::__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(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); 
        } 
    } 
     
    //注意,以下直接将参数 inst指定为 0。 
    typedef __malloc_alloc_template<0> malloc_alloc; 
     

     第一级配置器直接使用malloc(),free(),realloc()等C函数执行实际的内存配置、释放、重配置操作,并实现出类似C++ new handler机制。它有独特的out-of-memory内存处理机制:在抛出std::bad_alloc异常之前,调用内存不足处理例程尝试释放空间,如果用户没有定义相应的内存不足处理例程,那么还是会抛出异常。

    所谓C++ new handler机制是,你可以要求系统在内存配置要求无法被满足时,调用一个你所指定的函数。换句话说,一旦::operator new无法完成任务,在丢出std::bad_alloc异常状态之前,会先调用由客户端指定的处理例程,该处理例程通常即被称为new-handler。new-handler解决内存不足的做饭有特定的模式。

    请注意,SGI第一级配置器的allocate()和realloc()都是在调用malloc()和realloc()不成功后,该调用oom_malloc()和oom_realloc()。后两者都有内循环,不断调用“内存不足处理例程”,期望在某次调用之后,获得足够的内存而圆满完成任务。但如果“内存不足处理例程”并未被客户端设定,oom_malloc()和oom_realloc()便老实不客气地调用__THROW_BAD_ALLOC,丢出bad_alloc异常信息,或利用exit(1)硬生生中止程序。

    记住,设计“内存不足处理例程”是客端的责任,设定“内存不足处理例程”也是客端的责任。

    3 第二级配置器__default_alloc_template剖析

    本文讲解SGI STL空间配置器的第二级配置器。

    相比第一级配置器,第二级配置器多了一些机制,避免小额区块造成内存的碎片。不仅仅是碎片的问题,配置时的额外负担也是一个大问题。因为区块越小,额外负担所占的比例就越大。

    额外负担是指动态分配内存块的时候,位于其头部的额外信息,包括记录内存块大小的信息以及内存保护区(判断是否越界)。要想了解详细信息,请参考MSVC或者其他malloc实现。

    SGI STL第二级配置器具体实现思想

    如下:

    1. 如果要分配的区块大于128bytes,则移交给第一级配置器处理。
    2. 如果要分配的区块小于128bytes,则以内存池管理(memory pool),又称之次层配置(sub-allocation):每次配置一大块内存,并维护对应的自由链表(free-list)。下次若有相同大小的内存需求,则直接从free-list中取。如果有小额区块被释放,则由配置器回收到free-list中——是的,别忘了,配置器除了负责配置,也负责回收。 

    下面详细节介绍内存池管理技术。

    在第二级配置器中,小额区块内存需求大小都被上调至8的倍数,比如需要分配的大小是30bytes,就自动调整为32bytes。系统中总共维护16个free-lists,各自管理大小为8,16,...,128bytes的小额区块。

    为了维护链表,需要额外的指针,为了避免造成另外一种额外的负担,这里采用了一种技术:用union表示链表节点结构:

      union obj {
            union obj * free_list_link;//指向下一个节点
            char client_data[1];    /* The client sees this. */
      };
    

    union能够实现一物二用的效果,当节点所指的内存块是空闲块时,obj被视为一个指针,指向另一个节点。当节点已被分配时,被视为一个指针,指向实际区块。

    下面是第二级配置器的部分实现内容:

    enum {__ALIGN=8}; //小型区块的上调上界
    enum {__MAX_BYTES=128};  //小型区块的上限
    enum {__NFREELISTS=__MAX_BYRES/__ALIGN};  //free-lists个数
    

    以下是第二级配置器总体实现代码概览:

    template <bool threads, int inst>
    class __default_alloc_template {
    
    private:
      // 實際上我們應該使用 static const int x = N
      // 來取代 enum { x = N }, 但目前支援該性質的編譯器還不多。
    # ifndef __SUNPRO_CC
        enum {__ALIGN = 8};
        enum {__MAX_BYTES = 128};
        enum {__NFREELISTS = __MAX_BYTES/__ALIGN};
    # endif
      static size_t ROUND_UP(size_t bytes) {
            return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
      }
    __PRIVATE:
      union obj {
            union obj * free_list_link;
            char client_data[1];    /* The client sees this. */
      };
    private:
    # ifdef __SUNPRO_CC
        static obj * __VOLATILE free_list[]; 
            // Specifying a size results in duplicate def for 4.1
    # else
        static obj * __VOLATILE free_list[__NFREELISTS]; 
    # endif
      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;
    
     /* n must be > 0      */
      static void * allocate(size_t n){...}
    
     /* p may not be 0 */
      static void deallocate(void *p, size_t n){...}
     static void * reallocate(void *p, size_t old_sz, size_t new_sz);
    
    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, };

    空间配置函数allocate()

    具体实现如下:

    1. 要分配的区块小于128bytes,调用第一级配置器。
    2. 否则,向对应的free-list寻求帮助。
      • 对应的free list有可用的区块,直接拿过来用。
      • 如果没有可用的区块,调用函数refill()为free list重新填充空间。

    代码如下:

     /* n must be > 0      */
      static void * allocate(size_t n)
      {
        obj * __VOLATILE * my_free_list;
        obj * __RESTRICT result;
    
        if (n > (size_t) __MAX_BYTES) {
            return(malloc_alloc::allocate(n));
        }
        my_free_list = free_list + FREELIST_INDEX(n);
        // Acquire the lock here with a constructor call.
        // This ensures that it is released in exit or during stack
        // unwinding.
    #       ifndef _NOTHREADS
            /*REFERENCED*/
            lock lock_instance;
    #       endif
        result = *my_free_list;
        if (result == 0) {
            void *r = refill(ROUND_UP(n));
            return r;
        }
        *my_free_list = result -> free_list_link;
        return (result);
      };

    这里需要注意的是,每次都是从对应的free list的头部取出可用的内存块。
    图示如下:

    refill()-为free list填充空间

    当发现对应的free list没有可用的空闲区块时,就需要调用此函数重新填充空间。新的空间将取自于内存池(将经由chunk_alloc()完成)。缺省取得20个新节点(新区块),但万一内存池空间不足,获得的节点数(区块数)可能小于20,内存池的管理后面会讲到。

    /* Returns an object of size n, and optionally adds to size n 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>::refill(size_t n)
    {
        int nobjs = 20;
        //调用chunk_alloc(),尝试取得nobjs个区块作为free list的新节点,注意参数nobjs是pass by reference
        char * chunk = chunk_alloc(n, nobjs);
        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);
    
        /* Build free list in chunk */
          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 {
                current_obj -> free_list_link = next_obj;
            }
          }
        return(result);
    }

    chunk_alloc-从内存池中取空间供free list使用

    具体实现思想如下:

    1. 内存池剩余空间完全满足20个区块的需求量,则直接取出对应大小的空间。
    2. 内存池剩余空间不能完全满足20个区块的需求量,但是足够供应一个及一个以上的区块,则取出能够满足条件的区块个数的空间。
    3. 内存池剩余空间不能满足一个区块的大小,则
      • 首先判断内存池中是否有残余零头内存空间,如果有则进行回收,将其编入free list。
      • 然后向heap申请空间,补充内存池。
        • heap空间满足,空间分配成功。
        • heap空间不足,malloc()调用失败。则
          • 搜寻适当的free list(适当的是指:尚有未用区块,并且区块足够大),调整以进行释放,将其编入内存池。然后递归调用chunk_alloc函数从内存池取空间供free list。
          • 搜寻free list释放空间也未能解决问题,这时候调用第一级配置器,利用out-of-memory机制尝试解决内存不足问题。如果可以就成功,否则排除bad_alloc异常。

    源代码如下:

    缺省状况下取得20个新区块,但是如果内存池空间不够,取得的节点数就有可能小于20.下面是SGI STL中的源代码:

    /* We allocate memory in large chunks in order to avoid fragmenting     */
    /* the malloc heap 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>::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) {
            nobjs = bytes_left/size;
            total_bytes = size * nobjs;
            result = start_free;
            start_free += total_bytes;
            return(result);
        } else {
            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) {
                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) {
                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.
                start_free = (char *)malloc_alloc::allocate(bytes_to_get);
                // This should either throw an
                // exception or remedy the situation.  Thus we assume it
                // succeeded.
            }
            heap_size += bytes_to_get;
            end_free = start_free + bytes_to_get;
            return(chunk_alloc(size, nobjs));
        }
    }

    上述的chunk_alloc()函数以end_free-start_free来判断内存池的水量,如果水量充足,就直接调用20个区块返回给free list。如果水量不足以提供20个区块,但还足够供应一个以上的区块,就拔出这不足20个区块的空间出去。这时候其pass by reference的nobjs参数将被修改为实际能够供应的区块数。如果内存池连一个区块空间都无法供应,对客端显然无法交代,此时便需利用malloc()从heap中配置内存,为内存池注入活水以应付需求。新水量的大小为需求量的两倍,再加上一个随着配置次数增加而愈来愈大的附加量。

    举个例子,假设程序一开始,客端就调用chunk_alloc(32,20),于是 malloc()配置40个32bytes区块,其中第1个交出,另19个交给free_list[3]维护,余20个留给内存池。接下来客端调用chunk_alloc(64,20),此时free_list[7]也空空如也,必须向内存池要求支持。内存池只够供应(32*20)/64=10个bytes区块,就把这10个区块返回,第一个交给客端,余9个由free_list[7]维护。此时内存池全空。接下来再调用chunk_alloc(96,20),此时free_list[11]也空空如也,必须向内存池要求支持,而内存池此时也是空的,于是以malloc()配置40+n(附加量)个96bytes区块,其中交出1个,令19个交个free_list[11]维护,余20+n(附加量)个区块留给内存池。

    万一山穷水尽,整个system heap空间都不够了(以至于无法为内存池注入源头活水),malloc()行动失败,chunk_alloc()就四处寻找有无“尚有未用区域,且区块够大”之free lists。找到了就挖一块交出,找不到就调用第一级配置器,第一级配置器其实就是使用malloc()来配置内存,但它有out-of-memory处理机制,或许有机会释放其他的内存拿来此处使用,如果可以,就成功,否则发出bad_alloc异常。

    以上便是整个第二级配置器的设计。

    回想一些那个提供配置器标准接口的simple_alloc:

    template<class T, class Alloc>
    class simple_alloc{
        ...
    };
    
    SGI容器通常以这种方式来使用配置器:
    template<class T,class Alloc=alloc> //缺省使用alloc配置器
    class vector{
    public:
        typedef T value_type;
        ...
    protected:
        //专属之空间配置器,每次配置一个元素大小
        typedef simple_alloc<value_type,Alloc> data_allocator;
        ...
    };
    

      其中第二个tmplate参数所使用的缺省参数alloc,可以是第一级配置器也可以是第二级配置器。不过,SGI STL已经把它设为第二级配置器。

    deallocate()-空间释放函数

    1. 如果需要回收的区块大于128bytes,则调用第一级配置器。
    2. 如果需要回收的区块小于128bytes,找到对应的free -list,将区块回收。注意是将区块放入free -list的头部。

    SGI STL源代码:

     /* p may not be 0 */
      static void deallocate(void *p, size_t n)
      {
        obj *q = (obj *)p;
        obj * __VOLATILE * my_free_list;
    
        if (n > (size_t) __MAX_BYTES) {
            malloc_alloc::deallocate(p, n);
            return;
        }
        my_free_list = free_list + FREELIST_INDEX(n);
        // acquire lock
    #       ifndef _NOTHREADS
            /*REFERENCED*/
            lock lock_instance;
    #       endif /* _NOTHREADS */
        q -> free_list_link = *my_free_list;
        *my_free_list = q;
        // lock is released here
      }
  • 相关阅读:
    金融系列10《发卡行脚本》
    金融系列9《发卡行认证》
    金融系列8《应用密文产生》
    ED/EP系列5《消费指令》
    ED/EP系列4《圈存指令》
    ED/EP系列2《文件结构》
    ED/EP系列1《简介》
    社保系列11《ATR》
    社保系列3《文件结构》
    社保系列2《文件系统》
  • 原文地址:https://www.cnblogs.com/wuchanming/p/4161774.html
Copyright © 2011-2022 走看看