STL 之 空间配置器（allocator）

Posted 2020-07-20

 一、SGI 标准的空间配置器，std::allocator

SGI也定义了一个符合部分标准，名为allocator的配置器，但是它自己不使用，也不建议我们使用，主要原因是效率不佳。

它只是把C++的操作符::operator new和::operator delete做了一层简单的封装而已。

 

 

 

二、SGI 特殊的空间配置器，std::alloc

由于SGI 标准的空间配置器只是把C++的操作符::operator new和::operator delete做了一层简单的封装，没有考虑到任何效率上的强化。

所以 SGI 出现了一个特殊的空间配置器，供 STL标准模板库 使用。

 

通常，C++中用new操作符来分配内存都包括两个阶段：

（1）调用::operator new配置内存

（2）调用构造函数来构造对象内容

同理，delete操作也包括两个阶段：

（1）调用析构函数将对象析构

（2）调用::operator delete释放内存

 

为了精密分工，SGI STL allocator将两个阶段分开：

内存配置操作由alloc:allocate负责，内存释放由alloc:deallocate负责；对象构造操作由::contructor()负责，对象析构由::destroy()负责。

 

配置器定义在头文件<memory>中，它里面又包括两个文件：

#include <stl_alloc.h>        // 负责内存空间的配置和器释放  
#include <stl_construct.h>        // 负责对象的构造和析构  

 

 

STL 空间配置器：

STL 空间配置器解决的问题

1:内存碎片问题（外碎片）

内碎片，外碎片简介：

内碎片：操作系统在分配给申请者未被利用的部分。产生原因：内存对齐（效率高）；

外碎片：内存充足时但分配不出大块内存。产生原因：由于多次分配小块内存，将大块内存分割成小块；

 

2.频繁系统分配，释放小块内存，调用 malloc，delete 系统调用产生性能问题；

 

STL 空间配置器的实现机制：

双层级的配置器：

注：

当需要开辟的空间大于 128 bytes 时，视为“足够大”，调用一级配置器，直接调用 malloc，free；

当需要开辟的空间小于 128 bytes 时，视为“过小”，为了降低额外负担，调用二级空间配置器

 

 

一级空间配置器的剖析：

（set_new_handler 机制）

/*****************************************************************************
功能描述：一级空间配置器

类 /函数：template<int inst>  class __MallocAllocTemplate;

简    介：直接调用 malloc/free，内存分配失败后调用句柄处理函数
*****************************************************************************/

typedef void(*ALLOC_OOM_FUN)();  //内存分配失败以后处理的句柄handler类型
template<int inst>
class __MallocAllocTemplate
{
private:  
    static ALLOC_OOM_FUN __sMallocAllocOomHandler;
    static void* OomMalloc(size_t n)   //模仿 c++ 的 set_new_handler 机制
    {
        ALLOC_OOM_FUN handler = __sMallocAllocOomHandler;
        void* result;

        for (;;)  //一直循环，直到内存分配成功为止
        {
            if (handler == 0)  //检查是否设置处理的 handler
            {
                cout << "out of memory " << endl;
                exit(-1);
            }
            handler();    //调用客户自己的内存管理函数，释放内存
            result = malloc(n);  
            if (result)        //分配成功
                return result;
        }
    }

    static void* OomRealloc(void*p, size_t n)
    {
        ALLOC_OOM_FUN handler = __sMallocAllocOomHandler;
        void* result;

        for (;;)  //一直循环，直到内存分配成功为止
        {
            if (handler == 0)  //检查是否设置处理的 handler
            {
                cout << "out of memory " << endl;
                exit(-1);
            }
            handler();    //调用客户自己的内存管理函数，释放内存
            result = remalloc(n);
            if (result)        //分配成功
                return result;
        }
    }


public:
    static void* Allocate(size_t n)  //直接调用 malloc
    {
        void* result = malloc(n);
        return result == 0 ? OomMalloc(n) : result;
    }

    static void Deallocate(void* p)   //直接 free
    {
        free(p);
    }

    static void *Reallocate(void*p,size_t new_sz)
    {
        void* result = realloc(p, new_sz);
        return result == 0 ? OomRealloc(p, new_sz) : result;
    }

    static void(*SetMallocHandler(void(*f)()))()    //重新设置句柄处理函数
    {
        ALLOC_OOM_FUN result = __sMallocAllocOomHandler;
        __sMallocAllocOomHandler = f;
        return result;
    }
};

//初始化分配内存失败处理函数的句柄函数指针 
template<int inst>
ALLOC_OOM_FUN __MallocAllocTemplate<inst>::__sMallocAllocOomHandler = 0;

 

 

二级空间配置器：

 

 

 

template<bool threads, int inst>
class __DefaultAllocTemplate
{
public:
    enum{ __ALIGN = 8 };                        //排列基准值（也是排列间隔）   
    enum{ __MAX_BYTES = 128 };                   //最大值    
    enum{ __NFREELISTS = __MAX_BYTES / __ALIGN };    //排列链大小
    static size_t ROUND_UP(size_t bytes)
    {
        return (bytes + __ALIGN - 1 & ~(__ALIGN - 1));  //内存与 8 对齐
    }
    static size_t FREELIST_INDEX(size_t bytes)
    {
        return ((bytes + __ALIGN - 1) / __ALIGN - 1);  //返回在自由链表中的下标
    }

    union Obj
    {
        union Obj* _freeListLink;   //指向下一个内存块的指针
        char _clientData[1];   /* The client sees this.*/
    };

    static Obj* volatile _freeList[__NFREELISTS];    //自由链表    
    static char* _startFree;                        //内存池起始地址   
    static char* _endFree;                          //内存池结束地址    
    static size_t _heapSize;                        //内存池的容量   

    //从内存池中获取内存插入到自由链表中    
    static void* Refill(size_t n);
    //从内存池中分配内存   
    static char* ChunkAlloc(size_t size, int& nobjs);
    //用户调用申请内存函数
    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);
};

//初始化全局静态对象 
//1.自由链表
template<bool threads, int inst>
typename __DefaultAllocTemplate<threads, inst>::Obj* volatile
__DefaultAllocTemplate<threads, inst>::_freeList[__DefaultAllocTemplate<threads, inst>::__NFREELISTS];
//2.内存池
template<bool threads, int inst>
char* __DefaultAllocTemplate<threads, inst>::_startFree = 0;
template<bool threads, int inst>
char* __DefaultAllocTemplate<threads, inst>::_endFree = 0;
template<bool threads, int inst>
char* __DefaultAllocTemplate<threads, inst>::_heapSize = 0;


//类中声明函数的定义
template<bool threads, int inst>
void* __DefaultAllocTemplate<threads, inst>::Refill(size_t n)
{
    int nobjs = 20;
    char* result = ChunkAlloc(n, nobjs);
    if (nobjs == 1)
        return result;
    Obj* cur = (Obj*)(result + n);
    size_t index = FREELIST_INDEX(n);
        _freeList[index] = cur;
    for (int i = 2; i < nobjs; ++i)  //链表的头插
    {
        cur->_freeListLink = i*n + result;
        cur = cur->_freeListLink;
    }
    cur->_freeListLink = NULL;
    return result;
}


template<bool threads, int inst>
char* __DefaultAllocTemplate<threads, inst>::ChunkAlloc(size_t size, int&nobjs)
{
    char* result;
    size_t bytesNeed = size*nobjs;
    size_t bytesHave = _endFree - _startFree;

    if (bytesHave >= bytesNeed)   //内存池中所剩内存大于需要的内存
    {
        result = _startFree;
        _startFree += bytesNeed;
    }
    else if (bytesHave >= size)   //至少能满足一个 size 的分配
    {
        result = _startFree;
        nobjs = bytesHave / size;
        _startFree += size*nobjs;
    }
    else      //内存池中所剩空间不够一个 size
    {
        //清空内存池，准备往内存池中补充空间
        Obj* cur = _startFree;
        size_t index = FREELIST_INDEX(bytesHave);
        cur->_freeListLink = _freelist[index];
        _freelist[index] = cur;
        _startFree = NULL, _endFree = NULL;

        //重新向系统申请 bytesNeed*2 + _heapSize/16
        size_t bytesToGet = bytesNeed * 2 + (_heapSize >> 4);
        _startFree = (char*)malloc(bytesToGet);

        if (_startFree == NULL)    //向系统申请内存失败
        {
            //先向自由链表上游中的大块内存链中寻找
            for (int i = size; i <= __MAX_BYTES; i += __ALIGN)
            {
                Obj* head = _freeList[FREELIST_INDEX(size)];
                if (head)
                {
                    _startFree = (char*)head;
                    _endFree = (char*)head + i;
                    _freeList[FREELIST_INDEX(size)] = head->_freeListLink;
                    return ChunkAlloc(size, nobjs);
                }
            }
            //链表中也没有了，实在无奈，调用一级配置器中的内存分配函数
            _startFree = (char*)MallocAlloc::Allocate(byteToGet);
        }

        _heapSize += bytesToGet;
        _endFree = _startFree + bytesToGet;
        return ChunkAlloc(size, nobjs);  //函数的复用
    }
    return result;
}



template<bool threads, int inst>
void* __DefaultAllocTemplate<threads, inst>::Allocate(size_t n)
{
    void* result;
    if (n > __MAX_BYTES)
        result = MallocAlloc::Allocate(n);
    //
    //自由链表有，就直接取
    //没有，就通过 Refill进行填充
    //
    size_t index = FREELIST_INDEX(n);
    if (_freeList[index])
    {
        result = _freeList[index];
        _freelist[index] = ((Obj*)result)->_freeListLink;
    }
    else
    {
        result = Refill(ROUND_UP(n));
    }

    return result;
}

template<bool threads, int inst>
void __DefaultAllocTemplate<threads, inst>::Deallocate(void*p, size_t n)
{
    if (n > __MAX_BYTES)
        MallocAlloc::Deallocate(p);
    //不大于 __MAX_BYTES ，将此空间插回自由链表
    else
    {
        size_t index = FREELIST_INDEX(n);
        Obj* cur = (Obj*)p;
        cur->_freeListLink = _freeList[index];
        _freeList[index] = cur;
    }
}

template<bool threads, int inst>
void* __DefaultAllocTemplate<threads, inst>::Reallocate(void* p, size_t old_sz, size_t new_sz)
{
    void* result;
    if (old_sz > (size_t)__MAX_BYTES && new_sz > (size_t)__MAX_BYTES)    //
        return realloc(p, old_sz, new_sz);
    if (ROUND_UP(old_sz) == ROUND_UP(new_sz))
        return p;
    result = Allocate(new_sz);
    size_t size = old_sz > new_sz ? old_sz : new_sz;
    meycpy(result, p, size);
    Deallocate(p, old_sz);
    return result;
}


typedef __DefaultAllocTemplate<false, 0> Alloc;
#endif // __USE_MALLOC

二级空间配置器

 

STL 空间配置器的缺点：

1.有内碎片问题

2.内存池中的内存在程序结束前不能还给操作系统，被分割为小块的内存一直挂在自由链表下面，会使得内存的占用率过高。

 

 

学习ing，如果又发现哪有写的不对的地方请不吝赐教~~