空间配置器

最新推荐文章于 2024-04-22 16:54:39 发布
最新推荐文章于 2024-04-22 16:54:39 发布
阅读量500 收藏
点赞数 1
分类专栏： 数据结构 文章标签： stl 结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/f2016913/article/details/72859302
版权

一:为什么需要空间适配器?
我们知道地址空间的结构如下:
这里写图片描述
假设系统分配16byte,8byte,16byte,4byte,我们仅仅只是使用了16个字节的空间,当我们下次载要开一个32个字节的大小的空间,虽然内存够却开不了空间,因为空间不连续,只好在内存从新分配一个更大的空间,
1:出现小内存块的问题,
2:频繁的分配小块内存,效率比较低
二:我们看下STL中关于空间配置器:
这里写图片描述
一级空间配置器:
主要有三部分组成:
1:allocate调用malloc()开辟空间
2:deallcate调用free()释放空间;
3:模拟c++中的set_new_handler解决内存不足的问题;
一级空间配置器的实现

typedef void (*HANDLER_FUNC) ();//定义函数指针
template<int inst>
//表明开一个很大的内存块
class _MallocAllocTemplate
{
private:
    static HANDLER_FUNC __malloc_alloc_oom_handler;
public:
    static void*OOM_Malloc(size_t n) //主要解决内存不足的问题
    {
        void *result = NULL;
        while (1)
        {
            if (0 == __malloc_alloc_oom_handler)
            {
                throw bad_alloc();
            }
            __malloc_alloc_oom_handler();
            result = malloc(n);
            if (result)
                break;
        }
        return result;
    }
    //开空间
    static void * Allocate(size_t n)
    {
        void *result = malloc(n);//开空间
        __TRACE_DEBUG("一级空间配置器申请:0x%p,%d\n", result, n);
        if (0 == result)//表明开空间失败
            result = OOM_Malloc(n);
        return result;
    }
    //释放空间
    static void Deallocate(void *p, size_t n)
    {
        __TRACE_DEBUG("一级空间配置器释放:0x%p,%d\n",p, n);
        free(p);
    }

    HANDLER_FUNC SetMallocHandler(HANDLER_FUNC f)
    {
        HANDLER_FUNC old=f;
        __malloc_alloc_oom_handler = f;
        return old;

    }
};
//静态变量需要在类外面进行初始化
template<int inst>
HANDLER_FUNC _MallocAllocTemplate<inst>::__malloc_alloc_oom_handler = 0;

如果频繁的进行小块内存的申请和释放,我们如果解决呢?这就需要二级空间适配器.
三:二级空间适配器:
这里写图片描述
所谓的二级空间适配器就是由内存池和自由链表(free_list)组成.
我们用两个指针start_free表明内存池起始位置,end_free表明内存池尾部位置,
所谓的自由链表实际上是由16个大小的指针数组下面可以挂节点,我们可以看成直接定址的哈希,然后在表的下面挂上节点
二级空间配置器的做法是:
1:当内存空间大于128个字节时我们就认为是大空间,直接调用一级空间配置器中malloc分配内存
2:当内存块小于128时,由内存池管理,具体做法是每次配置一块内存要维护相应的自由链表,下次再进行相同的内存需求就直接在自由链表上拔出,如果用完需要归还,直接把自由链表的内存归还给内存池;
我们来看具体是怎么实现的?
free_list节点结构:

  union  Obj//free_list节点的结构
    {
        union Obj*FreeListLink;//自由链表下的内存块
        char client_data[1];
    };

空间配置Allocate()函数:
当需要的字节数大于128字节直接调用一级空间配置器,
如果小于128字节我们认为是小块内存,就可以采用内存池的管理机制,交给自由链表处理;当自由链表下面有内存块时,我们把从内存池取的内存连到自由链表的内存块下面,实际就是节点的插入:如果自由链表没有可用的区块那就将区块上调至8的倍数,然后调用rifill()为free_list填充空间
这里写图片描述

static void *Allocate(size_t n)
    {
        void *ret = NULL;
        //大于128个字节调用一级空间配置器
        if (n >__MAX_BYTES)
        {
            //调用一级空间配置器
            return _MallocAllocTemplate<inst>::Allocate(n);
        }
        __TRACE_DEBUG("二级空间配置器申请字节:%d\n", n);
        size_t index = FREELIST_INDEX(n);
        if (FreeList[index])//自由链表有内存块
        {

            Obj *ret= FreeList[index];
            FreeList[index] = ret->FreeListLink;
            return ret;
        }
        else
        {
            //调用refill从内存池填充自由链表,并返回内存池的第一个内存块
            size_t bytes = RoundUp(n);
            return Refill(bytes);
        }
        return ret;
    }

空间适配函数Dellocate()
1:内存块的大小大于128个字节,调一级空间配置器的dellocate()来进行空间的释放
2:如果是小块内存直接把小块内存回收到自由链表中,这样就可以避免系统频繁的申请和释放内存造成的内存碎片的问题;
这里写图片描述

static void Dellocate(void *p, size_t n)
    {
        if (p == NULL)
        {
            return ;
        }
        //表明大于128字节就调用一级空间配置器
        if (n > __MAX_BYTES)
        {
            return    _MallocAllocTemplate<inst>::Deallocate(p, n);

        }
        else
        {
            //放回free_list中
            size_t index = FREELIST_INDEX(n);
            ((Obj*)p)->FreeListLink = FreeList[index];
            FreeList[index] = (Obj*)p;
        }
        __TRACE_DEBUG("二级空间配置器释放:%d\n", n);
    }
};

重新填充Refill()
前面我们知道在alloc()开辟空间时,可能自由链表上的没有内存块,调用refill(),为free_list重新填充空间,新的内存块来自内存池,缺省取得20个新节点,但是内存池的空间可能小于20;
1;当内存块为1时,直接把这个内存块给调用者,就没有必要再链上自由链表;
2:否则就将内存池上的内存块拿下链到自由链表上

//表明从内存池上拿内存块填充自由链表
  static void *Refill(size_t size)
    {
        size_t nobjs = 20;//申请取20个内存块
        char *chunk = ChunkAlloc(size, nobjs);//表明将内存块作为free_list的新节点
        //如果只获得一个内存块,就将这个内存块直接个调用者用,free_list没有新节点
        if (nobjs == 1)
        {
            return chunk;
        }
        //调整free_list.将新节点链上自由链表中
        size_t index = FREELIST_INDEX(size);
        for (size_t  i = 1; i < nobjs; ++i)
        {
            Obj*obj = (Obj*)(chunk + i*size);
            obj->FreeListLink = FreeList[index];
            FreeList[index] = obj;
        }
        return chunk;
    }

ChunkAlloc()函数:
那么问题的关键来了,既然是在内存池里面取内存,取多少?万一内存池里面也没有内存如果解决呢?这里面的工作全都是由ChunkAlloc()来完成,让我们来看看它是如何工作的?
ChunkAlloc()函数首先判断内存池的剩余量(_EndFree_StartFree),当剩余的内存充足,表明可以满足需求,直接调出20个内存块的大小内存给自由链表;如果剩余量不足以提供20个内存块,但还足够供应1个以上的内存块,这时我们将nobjs修改为实际供应的内存块数,如果连一个内存块的空间也无法提供我们把内存池上的剩余空间给自由链表,如个内存池上也没有内存,我们在heap上malloc出空间填充内存池,如果malloc失败我们向自由链表上找剩余的内存.如果自由链表上也没有内存,就需要调用一级空间配置器.

  static char*ChunkAlloc(size_t size, size_t &nobjs)
    {
        size_t TotalBytes = size*nobjs;//表明总共需要需要的内存的大小
        size_t BytesLeft = _EndFree - _StartFree;//表明内存池中剩余的内存的多少
        //表明剩余的内存完全满足需求
        if (BytesLeft >= TotalBytes)
        {
            char *ret = _StartFree;
            _StartFree += TotalBytes;
            return ret;
        }
        //表明内存池的大小不能满足需求量但是可能满足一个块的大小
        else if (BytesLeft >= size)
        {

            nobjs = BytesLeft / size;
            TotalBytes = size*nobjs;
            char *ret = _StartFree;
            _StartFree += TotalBytes;
            return ret;
        }
        else
        {
            //表明内存池的大小连一个块的大小都提供不了;
            size_t BytesToGet = 2 * TotalBytes + RoundUp(_HeapSize >> 4);
            if (BytesLeft > 0)
            {
                size_t index = FREELIST_INDEX(BytesLeft);
                //表明将内存池的剩余的内存配给自由链表上
                ((Obj*)_StartFree)->FreeListLink = FreeList[index];
                FreeList[index] = (Obj*)_StartFree;
            }
            //配置heap空间,用来补充内存池
            _StartFree = (char*)malloc(BytesToGet);
            //表明malloc空间失败
            if (_StartFree == 0)
            {
                //继续向后搜索free_list中剩余的内存块
                for (size_t i = size; i < __NFREELISTS; ++i)
                {
                    //free_list中还有没有被用的内存块
                    if (FreeList[i])
                    {
                        //释放free_list中的内存块(把内存块归还给内存池)
                        Obj*cur = FreeList[i];
                        FreeList[i] = cur->FreeListLink;
                        _StartFree = (char *)cur;
                        _EndFree = _StartFree + (i + 1)*__ALIGN;
                        return ChunkAlloc(size, nobjs);
                    }
                }
                //表明free_list中也没有剩余的内存块
                _EndFree = 0; 
                //此时需要调用一级空间配置器
                _StartFree = (char *)_MallocAllocTemplate<inst>::Allocate(BytesToGet);
            }
            _HeapSize += BytesToGet;//从系统分配的总字节数(便于下次调用时使用)
            _EndFree = _StartFree + BytesToGet;
            return ChunkAlloc(size, nobjs);//递归调用,为了修正nobjs
        }
    }

二级空间配置器的实现:

二级空间适配器的实现:
template<bool threads,int inst>
class _DefaultAllocTemplate
{
    enum{ __ALIGN = 8 };//小区快上调的边界
    enum{__MAX_BYTES = 128 };//小区快的大小
    enum{ __NFREELISTS = __MAX_BYTES / __ALIGN };//free_list个数

    union  Obj//free_list节点的结构
    {
        union Obj*FreeListLink;//自由链表下的内存块
        char client_data[1];
    };

    static Obj*FreeList[__NFREELISTS];//自由链表节点的下标从0开始

    //chunk alloction state//内存块的状态
    static char *_StartFree;//表明内存池的起始位置
    static char *_EndFree;//内存池结束的位置
    static size_t _HeapSize;//反馈提哦啊接向系统申请字节大小

    static size_t FREELIST_INDEX(size_t bytes)
    {
        return (((bytes)+__ALIGN - 1) / __ALIGN - 1);//对齐到8
    }
    //将bytes上调到8的倍数
    static size_t RoundUp(size_t bytes)
    {
        return (((bytes)+__ALIGN - 1)&~(__ALIGN - 1));
    }

    //表明从内存池中取空间给free_list
    static char*ChunkAlloc(size_t size, size_t &nobjs)
    {


        size_t TotalBytes = size*nobjs;//表明总共需要需要的内存的大小
        size_t BytesLeft = _EndFree - _StartFree;//表明内存池中剩余的内存的多少
        //表明剩余的内存完全满足需求
        if (BytesLeft >= TotalBytes)
        {
            char *ret = _StartFree;
            _StartFree += TotalBytes;
            return ret;
        }
        //表明内存池的大小不能满足需求量但是可能满足一个块的大小
        else if (BytesLeft >= size)
        {

            nobjs = BytesLeft / size;
            TotalBytes = size*nobjs;
            char *ret = _StartFree;
            _StartFree += TotalBytes;
            return ret;
        }
        else
        {
            //表明内存池的大小连一个块的大小都提供不了;
            size_t BytesToGet = 2 * TotalBytes + RoundUp(_HeapSize >> 4);
            if (BytesLeft > 0)
            {
                size_t index = FREELIST_INDEX(BytesLeft);
                //表明将内存池的剩余的内存配给自由链表上
                ((Obj*)_StartFree)->FreeListLink = FreeList[index];
                FreeList[index] = (Obj*)_StartFree;
            }
            //配置heap空间,用来补充内存池
            _StartFree = (char*)malloc(BytesToGet);
            //表明malloc空间失败
            if (_StartFree == 0)
            {
                //继续向后搜索free_list中剩余的内存块
                for (size_t i = size; i < __NFREELISTS; ++i)
                {
                    //free_list中还有没有被用的内存块
                    if (FreeList[i])
                    {
                        //释放free_list中的内存块(把内存块归还给内存池)
                        Obj*cur = FreeList[i];
                        FreeList[i] = cur->FreeListLink;
                        _StartFree = (char *)cur;
                        _EndFree = _StartFree + (i + 1)*__ALIGN;
                        return ChunkAlloc(size, nobjs);
                    }
                }
                //表明free_list中也没有剩余的内存块
                _EndFree = 0; //(如果_EndFree不为0,下一次从内存池中取,就算抛异常以为会有内存,分配使用时程序崩溃)
                //此时需要调用一级空间配置器
                _StartFree = (char *)_MallocAllocTemplate<inst>::Allocate(BytesToGet);
            }
            _HeapSize += BytesToGet;//从系统分配的总字节数(便于下次调用时使用)
            _EndFree = _StartFree + BytesToGet;
            return ChunkAlloc(size, nobjs);//递归调用,为了修正nobjs
        }
    }
    //表明从内存池上拿内存块填充自由链表
    static void *Refill(size_t size)
    {
        size_t nobjs = 20;//申请取20个内存块
        char *chunk = ChunkAlloc(size, nobjs);//表明将内存块作为free_list的新节点
        //如果只获得一个内存块,就将这个内存块直接个调用者用,free_list没有新节点
        if (nobjs == 1)
        {
            return chunk;
        }
        //调整free_list.将新节点链上自由链表中
        size_t index = FREELIST_INDEX(size);
        for (size_t  i = 1; i < nobjs; ++i)
        {
            Obj*obj = (Obj*)(chunk + i*size);
            obj->FreeListLink = FreeList[index];
            FreeList[index] = obj;
        }
        return chunk;
    }
    public:
    //二级空间配置器的内存的申请
    //超过128字节表明大块内存需要到内存池里面申请空间
    static void *Allocate(size_t n)
    {
        void *ret = NULL;
        //大于128个字节调用一级空间配置器
        if (n >__MAX_BYTES)
        {
            //调用一级空间配置器
            return _MallocAllocTemplate<inst>::Allocate(n);
        }
        __TRACE_DEBUG("二级空间配置器申请字节:%d\n", n);
        size_t index = FREELIST_INDEX(n);
        if (FreeList[index])//自由链表有内存块
        {

            Obj *ret= FreeList[index];
            FreeList[index] = ret->FreeListLink;
            return ret;
        }
        else
        {
            //调用refill从内存池填充自由链表,并返回内存池的第一个内存块
            size_t bytes = RoundUp(n);
            return Refill(bytes);
        }
        return ret;
    }

    //空间释放
    static void Dellocate(void *p, size_t n)
    {
        if (p == NULL)
        {
            return ;
        }
        //表明大于128字节就调用一级空间配置器
        if (n > __MAX_BYTES)
        {
            return    _MallocAllocTemplate<inst>::Deallocate(p, n);

        }
        else
        {
            //放回free_list中
            size_t index = FREELIST_INDEX(n);
            ((Obj*)p)->FreeListLink = FreeList[index];
            FreeList[index] = (Obj*)p;
        }
        __TRACE_DEBUG("二级空间配置器释放:%d\n", n);
    }
};
//静态成员变量需要在类外面进行初始化
template<bool threads,int inst>
typename _DefaultAllocTemplate<threads, inst>::Obj*
_DefaultAllocTemplate<threads, inst>::FreeList[__NFREELISTS] = { 0 };
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>
size_t _DefaultAllocTemplate<threads, inst>::_HeapSize = 0;

trase配置文件:
有的时候我们希望借助一些辅助信息来还原我们代码的逻辑,一级得到一些我们想要的一些信息,我们就可以借助配置文件来完成:
Trase.h文件:

#define __DEBUG__
static string GetFileName(const string& path)
{
    char ch = '/';

#ifdef _WIN32
    ch = '\\';
#endif

    size_t pos = path.rfind(ch);
    if (pos == string::npos)
        return path;
    else
        return path.substr(pos + 1);
}

// 用于调试追溯的trace log
inline static void __trace_debug(const char* function,
    const char * filename, int line, char* format, ...)
{
    // 读取配置文件
#ifdef __DEBUG__
    // 输出调用函数的信息
    fprintf(stdout, "[ %s:%d]%s", GetFileName(filename).c_str(), line, function);

    // 输出用户打的trace信息
    va_list args;
    va_start(args, format);
    vfprintf(stdout, format, args);
    va_end(args);
#endif
}

#define __TRACE_DEBUG(...)  \
    __trace_debug(__FUNCTION__, __FILE__, __LINE__, __VA_ARGS__);

.cpp文件:

#include<iostream>
#include"Alloc.h"
using namespace std;
int main()
{
    void *p1 = _DefaultAllocTemplate<false, 1>::Allocate(129);
    _DefaultAllocTemplate<false, 1>::Dellocate(p1, 129);


    void *p2 = _DefaultAllocTemplate<false, 1>::Allocate(8);
    _DefaultAllocTemplate<false, 1>::Dellocate(p2, 8);


    system("pause");
    return 0;
}

这里写图片描述
关于这次的空间配置器就总结到这里,当然第一次分析源码,作为小白还有很多欠缺的地方,希望小伙伴们轻喷啊.

f2016913
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyTinySTL空间配置器源码
07-27
《MyTinySTL空间配置器源码解析》 在C++编程中，内存管理是至关重要的环节，尤其是在处理大量对象的存储与释放时。MyTinySTL是一个小型的C++标准模板库（STL）实现，它包含了基本的数据结构和算法，其中空间配置器...
空间配置器（allocator）详解-stl源码剖析学习笔记
weixin_42853463的博客
06-14 789
空间配置器也就是配置空间，配置容器所需要的空间，该空间获取可以是内存，也可以是磁盘或其他存储介质。
STL——空间配置器
weixin_57023347的博客
11-08 2795
目录 前言 一.概念 二.优点 三.空间配置器原理 3.1 一级空间配置器 3.2 二级空间配置器 3.2.1 内存池技术 3.2.2 哈希桶技术 四.内存碎片问题 4.1 外碎片 4.2 内碎片 五.具体细节 5.1 申请空间 5.2 填充内存块 5.3 向内存池中索要空间 前言 我们知道STL容器在不断保存...
【C++】空间配置器
zzg的学习博客
07-12 351
C++空间配置器 简要了解即可
STL之空间配置器
最新发布
木牛的博客
04-22 81
空间配置器，顾名思义就是为各个容器高效的管理空间(空间的申请与回收)的，在默默地工作。
STL-:SGI STL的二进制剖析以及直接封装的空间配置器代码
03-23
默认的空间配置器通常使用new运算符来分配和释放内存，但SGI STL提供了一种直接封装的空间配置器，允许开发者自定义内存管理策略，如预分配、池化分配等，以提高性能。这种封装的空间配置器代码通常包括如何分配、重...
my-mem-pool:剖析和注释SGI STL二级空间配置器源码与nginx内存池源码，并使用C ++ OOP进行仿写
03-23
我的内存池通过剖析的开源代码可以积累优秀的代码设计思想和良好的编程规范，了解不同的应用场景下不同的内存池实现也是一种重要的能力，本仓库对SGI STL二级空间配置器内核和nginx内存池内核进行了剖析，并使用C ++...
My-STL:C ++标准模板库基本容器，算法，空间配置器以及仿函数，类型萃取等C ++技巧的实现。
03-23
在"我的STL"项目中，我们可以看到对STL的基本容器、算法、空间配置器和仿函数的实现，同时也涵盖了C++的一些高级技巧，如类型萃取。下面将详细阐述这些关键概念。 一、基本容器 STL提供了多种容器，用于存储和操作...
【 C++ 】空间配置器
FLASH的博客
03-02 1025
STL笔记(二)---空间配置器
qq_44272681的博客
10-10 361
一、概述 allocator是STL的六大组件之一，空间配置器。其作用就是为各个容器管理内存(内存开辟 内存回收)。allocator配置的对象不只是内存,它也可以向硬盘索取空间。在这里我们主要考虑对内存的管理。我们在使用STL库的时候不用去考虑各种内存的操作,就是因为allocator已经帮我们做好了内存配置的工作。那么allocator是怎么实现内存的管理的呢? 对于一个标准的STL 容器，当vector<int> vec 的真实语句应该是 vetor<int, allocat
编程常用英语词汇
weixin_30888413的博客
04-18 838
转自：http://www.runoob.com/w3cnote/common-english-terminology-in-programming.html 编程常用英语词汇 分类 编程技术 按字母索引 A 开头 B 开头 C 开头 D 开头 E 开头 F 开头 G 开头 H 开头 I 开头 J 开头 K 开头 L 开头 ...
【C++】STL之空间配置器（了解）
Elena's Blog
01-31 1681
什么是空间配置器。
【STL源码剖析】【2、空间配置器——allocator】
zwh1298454060的博客
03-18 1129
【STL源码剖析】【2、空间配置器——allocator】
开发成长之路（6）-- C
2401_84049088的博客
04-07 635
还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！**
C++学习记录——삼십삼 STL空间配置器
kongqizyd146的博客
09-07 409
空间配置器
SGI_STL空间配置器源码剖析（一）总览
qq_20756957的博客
04-10 837
如下是SGI STL的stl_vector.h文件中，vector类相关的声明：上图展示了通过宏定义，vector 区分使用C++标准提供的内存分配器（allocator）还是使用SGI自己实现的空间配置器。# else# endif# endif从上面可以看到 __STL_DEFAULT_ALLOCATOR通过宏控制有两种实现，一种是，另一种是alloc，这两种分别就是SGI STL的一级空间配置器和二级空间配置器的实现。
STL的两级空间配置器
07-28
STL（Standard Template Library）中的两级空间配置器是为了提高内存分配和释放的效率而设计的。它分为两个级别：第一级空间配置器和第二级空间配置器。 第一级空间配置器是一个简单的内存分配器，直接调用全局的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值