1.STL空间配置器的类型和标准接口定义
allocator::value_type;
allocator::pointer;
allocator::const_pointer;
allocator::reference;
allocator::const_reference;
allocator::size_type;
allocator::difference_type;
allocator::rebind
// 一个嵌套的class template,class rebind<U>拥有唯一成员other,那是一个typedef,代表allocator<U>
allocator::allocator()
// default constructor
allocator::allocator(const allocator&)
// copy constructor
template <class U>allocator::allocator<const allocator<U>&()
// generic copy constructor
allocator::~allocator()
// default constructor
pointer allocator::address(reference x) const
// 返回对象的地址,等同于&x
const_pointer allocator::address(const_reference x)const
// 返回对象的地址,等同于&x
pointer allocator::allocate(size_type n, const void* = 0)
// 配置空间,足以存储n个T对象,第二参数是个提示,实现上可能利用它来增进区域性,或完全忽略之
void allocator::deallocate(pinter p, size_type n)
// 归还之前配置的空间
size_type allocator::max_size() const
// 按返回可成功配置的最大空间
void allocator::constructor(pointer p, const T&x)
// 等同于 new(const void* p ) T(x) 即placement new
void allocator::destroy(pinter p)
// 等同于 p->~T()
2.关于内存碎片问题
3.STL的两层空间配置器
由于以上的问题,SGI设计了两层的配置器,也就是第一级配置器和第二级配置器。同时为了自由选择,STL又规定了 __USE_MALLOC 宏,如果它存在则直接调用第一级配置器,不然则直接调用第二级配置器。SGI未定义该宏,也就是说默认使用第二级配置器。
需要注意的是,SGI版STL提供了一层更高级的封装,定义了一个simple_alloc类,无论是用哪一级都以模板参数alloc传给simple_alloc,这样对外体现都是只是simple_alloc
而它的代码实现比较简单,仅仅是调用一级或者二级配置器的接口
template<class T, class Alloc = AllocToUse>
class SimpleAlloc
{
public:
static T* Allocate()
{
return (T*)Alloc::Allocate(sizeof(T));
}
static T* Allocate(size_t n)
{
return n == 0 ? 0 : (T*)Alloc::Allocate(n * sizeof(T));
}
static void Deallocate(T* p)
{
if (p != NULL)
return Alloc::Deallocate(p, sizeof(T));
}
static void Deallocate(T* p, size_t n)
{
return Alloc::Deallocate(p, n * sizeof(T));
}
};
4.第一级空间配置器实现
#if 0
#include <new>
#define __THROW_BAD_ALLOC throw bas_alloc
#elif !defined(__THROW_BAD_ALLOC)
#include <iostream.h>
#define __THROW_BAD_ALLOC cerr << "out od memory" << endl; exit(1)
#endif
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
if (NULL == result)
{
result = oom_malloc(n); // 不满足时改用oom_malloc
}
return result;
}
static void* deallocate(void* p,,size_t /* n */)
{
free(p); // 第一级配置器直接使用free
}
static void* reallocate(void *p,size_t /* 0ld_sz */,size_t new_sz)
{
void * result = realloc(p,new_sz); // 第一级配置器直接使用realloc
if (NULL == result)
{
result= oom_realloc(p,new_sz);// 不满足时改用oom_realloc
}
return result;
}
// 模拟C++的set_new_handler,可以指定自己的oom handler
static void (* set_malloc_handler(void (*f)(void)))(void)
{
void (*lod)() = __malloc_alloc_oom_handler;
__malloc_alloc_oom_handler = f;
return (old);
}
};
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;
while (1) // 不断尝试释放,配置,再释放,再配置
{
my_malloc_handler = __malloc_alloc_oom_handler;
if (NULL == 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;
while (1) // 不断尝试释放,配置,再释放,再配置
{
my_malloc_handler = __malloc_alloc_oom_handler;
if (NULL == 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等库函数是向系统申请内存并且操作的函数。平时我们并不太会遇到内存空间分配不出来的情况,但是如果这一套程序是运行在服务器上的,各种各样的进程都需要内存。这样频繁的分配内存,终有一个时候,服务器再也分配不出内存,那么空间配置器该怎么办呢?这个函数指针指向的句柄函数就是处理这种情况的设计。
5.第二级空间配置器实现
根据情况来判定,如果配置区块大于128bytes,说明“足够大”,调用第一级配置器,而小于等于128bytes,则采用复杂内存池(memory pool)来管理。
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
//注意此处的位运算技巧,将bytes上调至8的倍数
static size_t ROUND_UP(size_t bytes)
{
return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
}
//注意此处的union技巧
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);
}
// 传回一个大小为n的对象,并可能加入大小为n的其他区块到free list
static void *refill(size_t n);
// 配置一大块空间,可容纳nobjs个大小为“size”的区块
// 如果配置nobjs个区块有所不便,nobjs可能会降低
static char *chunk_alloc(size_t size, int &nobjs);
// Chunk allocation state.
static char *start_free; // 记忆池起始位置,只在chunk_alloc()中变化
static char *end_free; // 记忆池结束位置,只在chunk_alloc()中变化
static size_t heap_size;
// 判断区块大小,大于128bytes就呼叫第一级配置器,小于128bytes就检查相应的free list。
// 如果free list之内有可用的区块,就直接拿来用。如果没有可用的区块,就将区块大小上调至8的倍数,然后呼叫refill
/* n must be > 0 */
static void * allocate(size_t n)
{
obj *volatile *my_free_list;
obj *result;
// 大于128bytes就呼叫第一级配置器
if (n > (size_t)__MAX_BYTES)
{
return (malloc_alloc::allocate(n));
}
// 否则,在free_list寻找合适的一个
my_free_list = free_list + FREELIST_INDEX(n);
result = *my_free_list;
if (NULL == result)
{
void *r = refill(ROUND_UP(n));// 如果没有合适的,就将n上调至8的倍数
return r;
}
// 调整free list
*my_free_list = result->free_list_link;
return result;
}
// n大于128bytes就呼叫第一级配置器,小于128bytes就找出对应的free list将区块回收
/* p may not be 0 */
static void deallocate(void *p, size_t n)
{
obj *q = (obj*)p;;
obj * volatile * my_free_list;
// 大于128bytes就呼叫第一级配置器
if (n > (size_t)__MAX_BYTES)
{
malloc_alloc::deallocate(p,n);
return;
}
// 否则,寻找对应的free list
my_free_list = free_list + FREELIST_INDEX(n);
// 调整free list,回收区块
q->free_list_link = *my_free_list;
*my_free_list = q;
}
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, };
};
// 几个调用的全域函数
// refill(),传回一个大小为n的对象,并且有时候会为适当的free list增加节点
// 假设n已经适当上调至8的倍数
template <bool threads,int inst>
void * __default_alloc_template<threads,inst>::refill(size_t n)
{
int nobjs = 20;
// 呼叫chunk_alloc(),尝试获得nobjs个区块作为free list的新节点
char * chunk = chunk_alloc(n,nobjs);
obj * volatile *my_free_list;
obj * result;
obj * current_obj,*next_obj;
int i;
// 如果只获得一个区块,这个区块就拨给呼叫者用,free list无新节点
if (1 == nobjs)
{
return chunk;
}
// 否则准备调整free list,纳入新节点
my_free_list = free_list + FREELIST_INDEX(n);
// 以下在chunk空间建立free list
result = (obj*)chunk; // 这一块准备传回给客端
// 以下导引free list指向新配置的空间(取自记忆池)
*my_free_list = next_obj = (obj*)(chunk + n);
// 以下将free list的各节点串接起来
for (i = 1; ; i++) // 从1开始,因为第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;
}
// 假设size已经适当上调至8的倍数
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);
// 以下试着让记忆池中的残余零头还有利用价值
if (bytes_left > 0)
{
// 首先寻找合适的free list
obj* volatile* my_free_list = free_list + FREELIST_INDEX(bytes_left);
// 调整free list,将记忆池中的残余空间编入
((obj*)start_free)->free_list_link = *my_free_list;
*my_free_list = (obj*)start_free;
}
// 配置heap空间
start_free = (char *)malloc(bytes_to_get);
if (NULL == start_free)
{
// heap空间不足,malloc失败
int i;
obj* volatile* my_fress_list,*p;
for (i = size;i <= __MAX_BYTES;i += __ALIGN)
{
my_free_list = free_list + FREELIST_INDEX(i);
p = *my_free_list;
if (0 != p) // free list内尚有未用区块
{
// 调整free list以释放出未用区块
*my_free_list = p->free_list_link;
start_free = (char*)p;
end_free = start_free + i;
// 递归呼叫自己,为了修正nobjs
return (chunk_alloc(size,nobjs));
// 注意,任何残余零头终将会被编入适当的free list中备用
}
}
end_free = 0;
// 呼叫第一级配置器,看看oom机制能否尽点力
start_free = (char*)malloc_alloc::allocate(bytes_to_get);
}
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
// 递归呼叫自己,为了修正nobjs
return (chunk_alloc(size,nobjs));
}
}
- 如果用户需要的区块大于128,则直接调用第一级空间配置器
- 如果用户需要的区块大于128,则到自由链表中去找
- 如果自由链表有,则直接去取走
- 不然则需要装填自由链表(Refill)
- 如果区块大于128, 则直接由第一级空间配置器收回
- 如果区块小于等于128, 则有自由链表收回
(3)chunkalloc函数分析
如果用户需要是一块n字节的区块,且n <= 128(调用第二级配置器),此时Refill填充是这样的:(需要注意的是:系统会自动将n字节扩展到8的倍数也就是RoundUP(n),再将RoundUP(n)传给Refill)。用户需要n块,且自由链表中没有,因此系统会向内存池申请nobjs * n大小的内存块,默认nobjs=20
- 如果内存池大于 nobjs * n,那么直接从内存池中取出
- 如果内存池小于nobjs * n,但是比一块大小n要大,那么此时将内存最大可分配的块数给自由链表,并且更新nobjs为最大分配块数x (x < nobjs)
- 如果内存池连一个区块的大小n都无法提供,那么首先先将内存池残余的零头给挂在自由链表上,然后向系统heap申请空间,申请成功则返回,申请失败则到自己的自由链表中看看还有没有可用区块返回,如果连自由链表都没了最后会调用一级配置器
- 如果只有一块返回给调用者,有多块,返回给调用者一块,剩下的挂在对应的位置。
6.什么是自由链表
我们在上面重点分析了整体思路,也就是二级配置器如何配置和是否内存,他们和一级配置器一样都提供Allocate和Deallocate的接口(其实还有个Reallocate也是用于分配内存,类似于C语言中realloc函数),我们都提到了一点自由链表,那么自由链表是个什么?
如上图所示,自由链表是一个指针数组,有点类似与hash桶,它的数组大小为16,每个数组元素代表所挂的区块大小,比如free_list[0]代表下面挂的是8bytes的区块,free_list[1]代表下面挂的是16bytes的区块…….依次类推,直到free _ list[15]代表下面挂的是128bytes的区块
同时我们还有一个被称为内存池地方,以start _ free和 end _ free记录其大小,用于保存未被挂在自由链表的区块,它和自由链表构成了伙伴系统。
我们之前讲了,如果用户申请小于等于128的区块,就到自由链表中取,但是如果自由链表对应的位置没了怎么办???这下子我们的内存池就发挥作用了!
7.最后
也就是STL可能存在的问题,通俗的讲就是优缺点吧
我们知道,引入相对的复杂的空间配置器,主要源自两点:
1. 频繁使用malloc,free开辟释放小块内存带来的性能效率的低下
2. 内存碎片问题,导致不连续内存不可用的浪费
引入两层配置器帮我们解决以上的问题,但是也带来一些问题:
- 内碎片的问题,自由链表所挂区块都是8的整数倍,因此当我们需要非8倍数的区块,往往会导致浪费,比如我只要1字节的大小,但是自由链表最低分配8块,也就是浪费了7字节,我以为这也就是通常的以空间换时间的做法,这一点在计算机科学中很常见。
- 我们发现似乎没有释放自由链表所挂区块的函数?确实是的,由于配置器的所有方法,成员都是静态的,那么他们就是存放在静态区。释放时机就是程序结束,这样子会导致自由链表一直占用内存,自己进程可以用,其他进程却用不了。
来源:https://blog.csdn.net/xy913741894/article/details/66974004