SGI STL源码之内存配置

好长时间没有写博客了，最近一直忙于看STL源码和实验室其它事情。在骑行了12公里的情况下，终于停歇下
来，静静地坐着，开始思考人生，思考STL是如何配置内存的。
1、SGI STL在配置内存的时候主要考虑了以下几点：

①向堆申请空间

②考虑了多线程

③考虑了内存碎片的问题

④考虑了当内存不足时的应变策略

在C++中申请堆内存使用的是new操作符，释放堆内存使用的是delete操作符，这两个操作符相当于C语言的

malloc()、free()函数。不知道是历史原因还是因为C++中没有realloc这种类似功能的函数(或操作符)，SGI STL在申请和释放内存时使用的是C语言函数。

至于多线程，就需要考虑同步的问题，以防多个线程同时修改全局变量。在Linux系统下采用的是互斥锁

(pthread_mutex_lock()、pthread_mutex_unlock())，在windows系统下采用的是临界区。

内存碎片的问题，也是本博客主要讲解的内容。SGI STL在内存碎片处理的问题上采用了两级配置器，第一级配

置器主要是用来配置大于128K字节的内存、第二级配置器主要是用来配置小于128K字节(小块内存)的内存。我们首先来看看第一级配置器做了什么。以下程序是我从源码中提炼出来的关于第一级配置的精华(源码稍后会给出)。

template<int ints>
class __malloc_alloc_template
{
public:
static void *allocate(int n)
{
void *tmp = malloc(n);
if (tmp == 0)
exit(1);
}
static void deallocate(void *p)
{
free(p);
}
static void *reallocate(void*p, int n)
{
void *tmp = realloc(p, n);
if (tmp == 0)
exit(1);
}
};

我们从代码中可以发现，第一级配置器主要是转调用C语言的malloc、free及realloc函数而已，其中的模板参数并没有什么用处。

第二级配置器的做法是如果配置的内存大于128K字节,就移交给第一级配置器去处理。当区块小于128字节时，

则以内存池的方式来管理：每次配置一大块内存，并维护对于的自由链表。如果下次再有相应大小的内存需求，则直接向自由链表中索取，如果客端释放小额区块，则有配置器回收到自由链表中。设计的理念是防止频繁的对小块内存的申请和释放。为了方便管理内存，SGI采用8字节对齐的方式，比如我需要12字节的内存，SGI会给你配置16个字节的内存，即向上取到8的倍数。第二级配置器维护了16个自由链表，负责维护16种小型区块的配置，下标从0开始，依次维护的内存大小为8、16、24、32、40、48、56、64、72、80、88、96、104、112、120、128(单位为字节)。自由链表的结构为：

union obj

{

union obj*free_list;

char client_data[1];

}

你是否能意识到此联合体的妙用？从第一个字段观之，obj可被看做是一个指针，指向相同形式的另一个obj。从其第二个字段观之，obj可被视为指针，指向实际的区块，一物二用。

下面我们以图解的方式来说明：



内存配置的具体过程：共分为三种情况：
①需求的内存大于128k，就调用第一级配置器，这种情况非常简单，就不做介绍。
②需求的内存小于128k，且自由链表中有可用的空间。根据需求的内存，计算出其应该去哪个自由链表中搜索。然后取出自由链表中第一个可用的空间，并修改自由链表的指针。比如，我们需求的内存为20个字节，向上取到8的倍数为24，因此我们应该去下标为2的自由链表中取内存。



③需求的内存小于128K，且自由链表中没有可用的内存。这时我们需要从内存池中获取内存。我们期望从内存池中一次性获取20个块，来填充自由链表。究竟能得到多少个块，这取决于内存池的当前容量。我们可以分为以下3中情形：
<1>内存池容量足够大。在这种情形下直接从内存池取出20个小块的容量填充到自由链表中。



<2>内存池有容量，但容量的大小只能提供1个及以上的块，不足于20个块的大小。此时，尽可能多地从内存池取内存来填充自由链表。



<3>内存池的容量不足于1个小块的需求。此时我们要把内存池中剩余的那点内存填充到合适的自由链表中，然后使用malloc申请一块大的堆内存，堆内存的大小为2*20*需求的小块。

下面的代码是我从源代码中提取的关于二级配置器分配内存的精华

/*第二级配置器*/
template<bool thread,int inst>
class __default_alloc_template
{
private:
enum{ ALINE = 8,MAXBYTES = 128, NUM_FREE_LIST = MAXBYTES/ALINE};
static char *start;//内存池的起始地址
static char *end;//内存池的结束地址
static int heap_size;//堆上已有内存的大小
union obj
{
union obj *free_list;
char client[1];
};
static obj *free_list[NUM_FREE_LIST];
static int round_up(int bytes)//上调至8的倍数
{
return ((bytes + ALINE - 1) & ~(ALINE - 1));
}
static int free_list_index(int bytes)//寻找自由链表的下标
{
return ((bytes + ALINE - 1) / ALINE - 1);
}
public:
static void *allocate(int size);
static void *refill(int size);
static char *chunk_alloc(int size, int &nobjs);
static void *reallocate(void *p,int old_size,int new_size);

static void deallocate(void *p,int size);
};

template<bool thread, int inst>
char *__default_alloc_template<thread, inst>::start = 0;

template<bool thread, int inst>
char *__default_alloc_template<thread, inst>::end = 0;

template<bool thread, int inst>
typename __default_alloc_template<thread, inst>::obj * __default_alloc_template<thread, inst>::free_list[NUM_FREE_LIST]
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

template<bool thread, int inst>
int __default_alloc_template<thread, inst>::heap_size = 0;

template<bool thread, int inst>
void *__default_alloc_template<thread, inst>::allocate(int size)
{
if (size > MAXBYTES)
return __malloc_alloc_template<0>::allocate(size);//使用第一级配置器

obj **my_free_list;
obj *result;
my_free_list = free_list + free_list_index(size);

result = *my_free_list;
if (0 == result)//自由链表没有可用的内存，进行重新填充
{
void *tmp = refill(round_up(size));
return tmp;
}
*my_free_list = result->free_list;
return result;
}

template<bool thread, int inst>
void *__default_alloc_template<thread, inst>::refill(int size)
{
int nobjs = 20;
char *chunk = chunk_alloc(size, nobjs);//nobjs按引用传递

if (1 == nobjs)//如果只够一个块的大小
return chunk;
/*如果有多个小块，则把这几个小块串成链表*/
obj **my_free_list = free_list + free_list_index(size);
obj *next;
next = *my_free_list = (obj*)(chunk + size);

for (int i = 1; i < nobjs - 1; i++)
{
next->free_list = (obj*)((char*)next + size);
next = next->free_list;
}
next->free_list = 0;
return chunk;
}

template<bool thread, int inst>
char *__default_alloc_template<thread, inst>::chunk_alloc(int size, int &nobjs)
{
int need_size = size * nobjs;
int left_size = end - start;
char *result = start;
/*内存池中的内存足够用*/
if (left_size >= need_size)
{
start += need_size;
return result;
}
/*内存池中空间不够，但足够一个以上的块使用*/
else if (left_size >= size)
{
nobjs = left_size / size;
start += nobjs * size;
return result;
}
/*内存池剩余的空间满足不了一个小块的需求*/
else
{
int bytes_to_get = 2 * need_size + round_up(heap_size >> 4);
/*尝试利用内存池剩余的零头*/
if (left_size > 0)
{
obj **my_free_list = free_list + free_list_index(left_size);
obj *tmp = *my_free_list;
*my_free_list = (obj *)start;
(*my_free_list)->free_list = tmp;
}
/*配置堆用来补充内存池*/
result = (char *)malloc(bytes_to_get);
/*只做简单的处理：没有足够的内存则终止程序*/
if (result == 0)
exit(1);

start = result + need_size;
end = result + bytes_to_get;
heap_size += bytes_to_get;
return result;
}
}
template<bool thread, int inst>
void *__default_alloc_template<thread, inst>::reallocate(void *p, int old_size, int new_size)
{
/*如果新旧内存都大于MAXBYTES*/
if (old_size > MAXBYTES && new_size > MAXBYTES)
return realloc(p, new_size);
/*如果新旧内存调整到8的倍数后相等*/
if (round_up(old_size) == round_up(new_size))
return p;
void *result = allocate(new_size);
int min_copy = old_size > new_size ? new_size : old_size;
memcpy(result, p, min_copy);
deallocate(p, old_size);
return result;
}

template<bool thread, int inst>
void __default_alloc_template<thread, inst>::deallocate(void *p, int size)
{
if (size > MAXBYTES)
malloc_alloc::deallocate(p);
/*回收到自由列表中*/
else
{
obj**my_free_list = free_list + free_list_index(size);
obj *tmp = *my_free_list;
*my_free_list = (obj*)p;
(*my_free_list)->free_list = tmp;
}
}

二级配置器又是如何回收内存的呢？如果回收的内存大于128字节，那么直接交给第一级配置器进行free掉；如果回收的内存小于128字节，则直接回收到自由链表中。



SGI STL的源码如下：

#ifndef __SGI_STL_INTERNAL_ALLOC_H
#define __SGI_STL_INTERNAL_ALLOC_H

#ifdef __SUNPRO_CC
#  define __PRIVATE public
#else
#  define __PRIVATE private
#endif

#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
#  define __USE_MALLOC
#endif

/* 这实现了一些标准的节点配置.这些与在C++标准草案或在原STL分配器都不一样。
它们不封装不同的指针类型；事实上，我们假设只有一个指针类型。
配置元素的目的是分配对象，与原来的STL分配器相比没有更大的用途。
*/
/**********************19~28行主要是处理内存溢出***********************************/
#ifndef __THROW_BAD_ALLOC
#  if defined(__STL_NO_BAD_ALLOC) || !defined(__STL_USE_EXCEPTIONS)
#    include <stdio.h>
#    include <stdlib.h>
#    define __THROW_BAD_ALLOC fprintf(stderr, "out of memory\n"); exit(1)
#  else
#    include <new>
#    define __THROW_BAD_ALLOC throw std::bad_alloc()
#  endif
#endif

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#ifndef __RESTRICT
#  define __RESTRICT
#endif

#ifdef __STL_THREADS
# include <stl_threads.h>
# define __NODE_ALLOCATOR_THREADS true
# ifdef __STL_SGI_THREADS
// We test whether threads are in use before locking.
// Perhaps this should be moved into stl_threads.h, but that
// probably makes it harder to avoid the procedure call when
// it isn't needed.
extern "C" {
extern int __us_rsthread_malloc;
}
// The above is copied from malloc.h.  Including <malloc.h>
// would be cleaner but fails with certain levels of standard
// conformance.
#   define __NODE_ALLOCATOR_LOCK if (threads && __us_rsthread_malloc) \
{ _S_node_allocator_lock._M_acquire_lock(); }
#   define __NODE_ALLOCATOR_UNLOCK if (threads && __us_rsthread_malloc) \
{ _S_node_allocator_lock._M_release_lock(); }
# else /* !__STL_SGI_THREADS */
#   define __NODE_ALLOCATOR_LOCK \
{ if (threads) _S_node_allocator_lock._M_acquire_lock(); }
#   define __NODE_ALLOCATOR_UNLOCK \
{ if (threads) _S_node_allocator_lock._M_release_lock(); }
# endif
#else
//  Thread-unsafe
#   define __NODE_ALLOCATOR_LOCK
#   define __NODE_ALLOCATOR_UNLOCK
#   define __NODE_ALLOCATOR_THREADS false
#endif

__STL_BEGIN_NAMESPACE

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1174
#endif

// Malloc-based allocator.  Typically slower than default alloc below.
// Typically thread-safe and more storage efficient.
#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
# ifdef __DECLARE_GLOBALS_HERE
void (* __malloc_alloc_oom_handler)() = 0;
// g++ 2.7.2 does not handle static template data members.
# else
extern void (* __malloc_alloc_oom_handler)();
# endif
#endif

template <int __inst>
class __malloc_alloc_template
{
private:

static void* _S_oom_malloc(size_t);
static void* _S_oom_realloc(void*, size_t);

#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
static void (* __malloc_alloc_oom_handler)();
#endif

public:

static void* allocate(size_t __n)
{
void* __result = malloc(__n);
if (0 == __result) __result = _S_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 = _S_oom_realloc(__p, __new_sz);
return __result;
}

static void (* __set_malloc_handler(void (*__f)()))()
{
void (* __old)() = __malloc_alloc_oom_handler;
__malloc_alloc_oom_handler = __f;
return(__old);
}

};

// 内存溢出处理函数
#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
template <int __inst>
void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;
#endif

template <int __inst>
void*
__malloc_alloc_template<__inst>::_S_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>::_S_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);
}
}

typedef __malloc_alloc_template<0> malloc_alloc;
/*定义此类的目的是使配置器的接口能够符合STL规格，内部函数
只是转调用而已，或者调用第一级的配置器或调用第二级的配置器*/
template<class _Tp, class _Alloc>
class simple_alloc
{
public:
static _Tp* allocate(size_t __n)
{ return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
static _Tp* allocate(void)
{ return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
static void deallocate(_Tp* __p, size_t __n)
{ if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
static void deallocate(_Tp* __p)
{ _Alloc::deallocate(__p, sizeof (_Tp)); }
};

// Allocator adaptor to check size arguments for debugging.
// Reports errors using assert.  Checking can be disabled with
// NDEBUG, but it's far better to just use the underlying allocator
// instead when no checking is desired.
// There is some evidence that this can confuse Purify.
template <class _Alloc>
class debug_alloc {

private:

enum {_S_extra = 8};  // Size of space used to store size.  Note
// that this must be large enough to preserve
// alignment.

public:

static void* allocate(size_t __n)
{
char* __result = (char*)_Alloc::allocate(__n + (int) _S_extra);
*(size_t*)__result = __n;
return __result + (int) _S_extra;
}

static void deallocate(void* __p, size_t __n)
{
char* __real_p = (char*)__p - (int) _S_extra;
assert(*(size_t*)__real_p == __n);
_Alloc::deallocate(__real_p, __n + (int) _S_extra);
}

static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz)
{
char* __real_p = (char*)__p - (int) _S_extra;
assert(*(size_t*)__real_p == __old_sz);
char* __result = (char*)
_Alloc::reallocate(__real_p, __old_sz + (int) _S_extra,
__new_sz + (int) _S_extra);
*(size_t*)__result = __new_sz;
return __result + (int) _S_extra;
}

};

# ifdef __USE_MALLOC

typedef malloc_alloc alloc;
typedef malloc_alloc single_client_alloc;

# else

#if defined(__SUNPRO_CC) || defined(__GNUC__)
// breaks if we make these template class members:
enum {_ALIGN = 8};
enum {_MAX_BYTES = 128};
enum {_NFREELISTS = 16}; // _MAX_BYTES/_ALIGN
#endif
/*第二级配置器*/
template <bool threads, int inst>
class __default_alloc_template
{
private:
#if ! (defined(__SUNPRO_CC) || defined(__GNUC__))
enum {_ALIGN = 8};//对齐字节数
enum {_MAX_BYTES = 128};//块的最大字节数
enum {_NFREELISTS = 16}; // 16个自由链表
# endif
static size_t _S_round_up(size_t __bytes) //将__bytes提升到8的倍数
{
return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1));
}

__PRIVATE:
union _Obj //自由链表的节点结构
{
union _Obj* _M_free_list_link;
char _M_client_data[1];
};
private:
# if defined(__SUNPRO_CC) || defined(__GNUC__) || defined(__HP_aCC)
static _Obj* __STL_VOLATILE _S_free_list[];
# else
static _Obj* __STL_VOLATILE _S_free_list[_NFREELISTS];
# endif
static  size_t _S_freelist_index(size_t __bytes)//__bytes所在自由链表的下标
{
return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1);
}

static void* _S_refill(size_t __n);//重新填充自由链表
static char* _S_chunk_alloc(size_t __size, int& __nobjs);//分配大块内存
// 大块内存的状态
static char* _S_start_free;//内存池的起始位置
static char* _S_end_free;//内存池的结束位置
static size_t _S_heap_size;//堆的大小

# ifdef __STL_THREADS
static _STL_mutex_lock _S_node_allocator_lock;//如果定义了线程，则声明一个互斥锁
# endif

class _Lock;
friend class _Lock;
class _Lock //主要是用来线程之间的同步
{
public:
_Lock() { __NODE_ALLOCATOR_LOCK; }
~_Lock() { __NODE_ALLOCATOR_UNLOCK; }
}；
public:
static void* allocate(size_t __n)//分配内存
{
void* __ret = 0;

if (__n > (size_t) _MAX_BYTES)//如果需求内存大于128，则调用第一级配置器
{
__ret = malloc_alloc::allocate(__n);
}
else
{
_Obj* __STL_VOLATILE* __my_free_list = _S_free_list + _S_freelist_index(__n);

#ifndef _NOTHREADS
_Lock __lock_instance;
#endif

_Obj* __RESTRICT __result = *__my_free_list;
if (__result == 0)
__ret = _S_refill(_S_round_up(__n));//自由链表中没有内存则去内存池中寻找内存来填充自由链表
else
{
*__my_free_list = __result -> _M_free_list_link;
__ret = __result;
}
}
return __ret;
};

static void deallocate(void* __p, size_t __n)//回收内存
{
if (__n > (size_t) _MAX_BYTES)//如果回收内存大于128，则直接交给第一级配置器free掉
malloc_alloc::deallocate(__p, __n);
else
{
_Obj* __STL_VOLATILE*  __my_free_list = _S_free_list + _S_freelist_index(__n);
_Obj* __q = (_Obj*)__p;

#ifndef _NOTHREADS
_Lock __lock_instance;
#endif /* _NOTHREADS */
__q -> _M_free_list_link = *__my_free_list;
*__my_free_list = __q;
}
}

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>
inline bool operator==(const __default_alloc_template<__threads, __inst>&,const __default_alloc_template<__threads, __inst>&)
{
return true;
}

# ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <bool __threads, int __inst>
inline bool operator!=(const __default_alloc_template<__threads, __inst>&,const __default_alloc_template<__threads, __inst>&)
{
return false;
}
# endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

template <bool __threads, int __inst>
char*__default_alloc_template<__threads, __inst>::_S_chunk_alloc(size_t __size, int& __nobjs)
{
char* __result;
size_t __total_bytes = __size * __nobjs;
size_t __bytes_left = _S_end_free - _S_start_free;

if (__bytes_left >= __total_bytes)
{
__result = _S_start_free;
_S_start_free += __total_bytes;
return(__result);
}
else if (__bytes_left >= __size)
{
__nobjs = (int)(__bytes_left/__size);
__total_bytes = __size * __nobjs;
__result = _S_start_free;
_S_start_free += __total_bytes;
return(__result);
}
else
{
size_t __bytes_to_get = 2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
if (__bytes_left > 0)
{
_Obj* __STL_VOLATILE* __my_free_list =_S_free_list + _S_freelist_index(__bytes_left);

((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;
*__my_free_list = (_Obj*)_S_start_free;
}
_S_start_free = (char*)malloc(__bytes_to_get);
if (0 == _S_start_free)
{
size_t __i;
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __p;
for (__i = __size;__i <= (size_t) _MAX_BYTES;__i += (size_t) _ALIGN)
{
__my_free_list = _S_free_list + _S_freelist_index(__i);
__p = *__my_free_list;
if (0 != __p)
{
*__my_free_list = __p -> _M_free_list_link;
_S_start_free = (char*)__p;
_S_end_free = _S_start_free + __i;
return(_S_chunk_alloc(__size, __nobjs));
}
}
_S_end_free = 0;	// In case of exception.
_S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get);
}
_S_heap_size += __bytes_to_get;
_S_end_free = _S_start_free + __bytes_to_get;
return(_S_chunk_alloc(__size, __nobjs));
}
}

template <bool __threads, int __inst>
void*__default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
{
int __nobjs = 20;
char* __chunk = _S_chunk_alloc(__n, __nobjs);
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __result;
_Obj* __current_obj;
_Obj* __next_obj;
int __i;

if (1 == __nobjs) return(__chunk);
__my_free_list = _S_free_list + _S_freelist_index(__n);

__result = (_Obj*)__chunk;
*__my_free_list = __next_obj = (_Obj*)(__chunk + __n);
for (__i = 1; ; __i++)
{
__current_obj = __next_obj;
__next_obj = (_Obj*)((char*)__next_obj + __n);
if (__nobjs - 1 == __i)
{
__current_obj -> _M_free_list_link = 0;
break;
}
else
{
__current_obj -> _M_free_list_link = __next_obj;
}
}
return(__result);
}

template <bool threads, int inst>
void*__default_alloc_template<threads, inst>::reallocate(void* __p,size_t __old_sz,size_t __new_sz)
{
void* __result;
size_t __copy_sz;

if (__old_sz > (size_t) _MAX_BYTES && __new_sz > (size_t) _MAX_BYTES)
{
return(realloc(__p, __new_sz));
}
if (_S_round_up(__old_sz) == _S_round_up(__new_sz))
return(__p);
__result = allocate(__new_sz);
__copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
memcpy(__result, __p, __copy_sz);
deallocate(__p, __old_sz);
return(__result);
}

#ifdef __STL_THREADS
template <bool __threads, int __inst>
_STL_mutex_lock
__default_alloc_template<__threads, __inst>::_S_node_allocator_lock
__STL_MUTEX_INITIALIZER;
#endif

template <bool __threads, int __inst>
char* __default_alloc_template<__threads, __inst>::_S_start_free = 0;

template <bool __threads, int __inst>
char* __default_alloc_template<__threads, __inst>::_S_end_free = 0;

template <bool __threads, int __inst>
size_t __default_alloc_template<__threads, __inst>::_S_heap_size = 0;

template <bool __threads, int __inst>
typename __default_alloc_template<__threads, __inst>::_Obj* __STL_VOLATILE
__default_alloc_template<__threads, __inst> ::_S_free_list[
# if defined(__SUNPRO_CC) || defined(__GNUC__) || defined(__HP_aCC)
_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, };
#endif /* ! __USE_MALLOC */

#ifdef __STL_USE_STD_ALLOCATORS

template <class _Tp>
class allocator
{
typedef alloc _Alloc;          // 根本的配置器
public:
typedef size_t     size_type;
typedef ptrdiff_t  difference_type;
typedef _Tp*       pointer;
typedef const _Tp* const_pointer;
typedef _Tp&       reference;
typedef const _Tp& const_reference;
typedef _Tp        value_type;

template <class _Tp1>
struct rebind
{
typedef allocator<_Tp1> other;
};

allocator() __STL_NOTHROW {}
allocator(const allocator&) __STL_NOTHROW {}
template <class _Tp1>
allocator(const allocator<_Tp1>&) __STL_NOTHROW {}
~allocator() __STL_NOTHROW {}

pointer address(reference __x) const { return &__x; }
const_pointer address(const_reference __x) const { return &__x; }

_Tp* allocate(size_type __n, const void* = 0)
{
return __n != 0 ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp))) : 0;
}

void deallocate(pointer __p, size_type __n)
{ _Alloc::deallocate(__p, __n * sizeof(_Tp)); }

size_type max_size() const __STL_NOTHROW
{ return size_t(-1) / sizeof(_Tp); }

void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
void destroy(pointer __p) { __p->~_Tp(); }
};

template<>
class allocator<void> {
public:
typedef size_t      size_type;
typedef ptrdiff_t   difference_type;
typedef void*       pointer;
typedef const void* const_pointer;
typedef void        value_type;

template <class _Tp1> struct rebind {
typedef allocator<_Tp1> other;
};
};

template <class _T1, class _T2>
inline bool operator==(const allocator<_T1>&, const allocator<_T2>&)
{
return true;
}

template <class _T1, class _T2>
inline bool operator!=(const allocator<_T1>&, const allocator<_T2>&)
{
return false;
}

// Allocator adaptor to turn an SGI-style allocator (e.g. alloc, malloc_alloc)
// into a standard-conforming allocator.   Note that this adaptor does
// *not* assume that all objects of the underlying alloc class are
// identical, nor does it assume that all of the underlying alloc's
// member functions are static member functions.  Note, also, that
// __allocator<_Tp, alloc> is essentially the same thing as allocator<_Tp>.

template <class _Tp, class _Alloc>
struct __allocator {
_Alloc __underlying_alloc;

typedef size_t    size_type;
typedef ptrdiff_t difference_type;
typedef _Tp*       pointer;
typedef const _Tp* const_pointer;
typedef _Tp&       reference;
typedef const _Tp& const_reference;
typedef _Tp        value_type;

template <class _Tp1> struct rebind {
typedef __allocator<_Tp1, _Alloc> other;
};

__allocator() __STL_NOTHROW {}
__allocator(const __allocator& __a) __STL_NOTHROW
: __underlying_alloc(__a.__underlying_alloc) {}
template <class _Tp1>
__allocator(const __allocator<_Tp1, _Alloc>& __a) __STL_NOTHROW
: __underlying_alloc(__a.__underlying_alloc) {}
~__allocator() __STL_NOTHROW {}

pointer address(reference __x) const { return &__x; }
const_pointer address(const_reference __x) const { return &__x; }

// __n is permitted to be 0.
_Tp* allocate(size_type __n, const void* = 0) {
return __n != 0
? static_cast<_Tp*>(__underlying_alloc.allocate(__n * sizeof(_Tp)))
: 0;
}

// __p is not permitted to be a null pointer.
void deallocate(pointer __p, size_type __n)
{ __underlying_alloc.deallocate(__p, __n * sizeof(_Tp)); }

size_type max_size() const __STL_NOTHROW
{ return size_t(-1) / sizeof(_Tp); }

void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
void destroy(pointer __p) { __p->~_Tp(); }
};

template <class _Alloc>
class __allocator<void, _Alloc> {
typedef size_t      size_type;
typedef ptrdiff_t   difference_type;
typedef void*       pointer;
typedef const void* const_pointer;
typedef void        value_type;

template <class _Tp1> struct rebind {
typedef __allocator<_Tp1, _Alloc> other;
};
};

template <class _Tp, class _Alloc>
inline bool operator==(const __allocator<_Tp, _Alloc>& __a1,
const __allocator<_Tp, _Alloc>& __a2)
{
return __a1.__underlying_alloc == __a2.__underlying_alloc;
}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <class _Tp, class _Alloc>
inline bool operator!=(const __allocator<_Tp, _Alloc>& __a1,
const __allocator<_Tp, _Alloc>& __a2)
{
return __a1.__underlying_alloc != __a2.__underlying_alloc;
}
#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

// Comparison operators for all of the predifined SGI-style allocators.
// This ensures that __allocator<malloc_alloc> (for example) will
// work correctly.

template <int inst>
inline bool operator==(const __malloc_alloc_template<inst>&,
const __malloc_alloc_template<inst>&)
{
return true;
}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <int __inst>
inline bool operator!=(const __malloc_alloc_template<__inst>&,
const __malloc_alloc_template<__inst>&)
{
return false;
}
#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

template <class _Alloc>
inline bool operator==(const debug_alloc<_Alloc>&,
const debug_alloc<_Alloc>&) {
return true;
}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <class _Alloc>
inline bool operator!=(const debug_alloc<_Alloc>&,
const debug_alloc<_Alloc>&) {
return false;
}
#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

template <class _Tp, class _Allocator>
struct _Alloc_traits
{
static const bool _S_instanceless = false;
typedef typename _Allocator::__STL_TEMPLATE rebind<_Tp>::other
allocator_type;
};

template <class _Tp, class _Allocator>
const bool _Alloc_traits<_Tp, _Allocator>::_S_instanceless;

// The version for the default allocator.

template <class _Tp, class _Tp1>
struct _Alloc_traits<_Tp, allocator<_Tp1> >
{
static const bool _S_instanceless = true;
typedef simple_alloc<_Tp, alloc> _Alloc_type;
typedef allocator<_Tp> allocator_type;
};

// Versions for the predefined SGI-style allocators.

template <class _Tp, int __inst>
struct _Alloc_traits<_Tp, __malloc_alloc_template<__inst> >
{
static const bool _S_instanceless = true;
typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
};

template <class _Tp, bool __threads, int __inst>
struct _Alloc_traits<_Tp, __default_alloc_template<__threads, __inst> >
{
static const bool _S_instanceless = true;
typedef simple_alloc<_Tp, __default_alloc_template<__threads, __inst> >
_Alloc_type;
typedef __allocator<_Tp, __default_alloc_template<__threads, __inst> >
allocator_type;
};

template <class _Tp, class _Alloc>
struct _Alloc_traits<_Tp, debug_alloc<_Alloc> >
{
static const bool _S_instanceless = true;
typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
};

// Versions for the __allocator adaptor used with the predefined
// SGI-style allocators.

template <class _Tp, class _Tp1, int __inst>
struct _Alloc_traits<_Tp,
__allocator<_Tp1, __malloc_alloc_template<__inst> > >
{
static const bool _S_instanceless = true;
typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
};

template <class _Tp, class _Tp1, bool __thr, int __inst>
struct _Alloc_traits<_Tp,
__allocator<_Tp1,
__default_alloc_template<__thr, __inst> > >
{
static const bool _S_instanceless = true;
typedef simple_alloc<_Tp, __default_alloc_template<__thr,__inst> >
_Alloc_type;
typedef __allocator<_Tp, __default_alloc_template<__thr,__inst> >
allocator_type;
};

template <class _Tp, class _Tp1, class _Alloc>
struct _Alloc_traits<_Tp, __allocator<_Tp1, debug_alloc<_Alloc> > >
{
static const bool _S_instanceless = true;
typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
};

#endif /* __STL_USE_STD_ALLOCATORS */

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1174
#endif

__STL_END_NAMESPACE

#undef __PRIVATE

#endif /* __SGI_STL_INTERNAL_ALLOC_H */

// Local Variables:
// mode:C++
// End: