《STL源码剖析》--stl_alloc.h
来源:互联网 发布:apache tomcat 7.0.79 编辑:程序博客网 时间:2024/05/04 13:54
// Filename: stl_alloc.h// Comment By: 凝霜// E-mail: mdl2009@vip.qq.com// Blog: http://blog.csdn.net/mdl13412// 特别说明: SGI STL的allocator在我的编译环境下不使用内存池// 而其内存池不进行内存释放操作, 其释放时机为程序退出或者stack unwinding// 由操作系统保证内存的回收/* * Copyright (c) 1996-1997 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. *//* NOTE: This is an internal header file, included by other STL headers. * You should not attempt to use it directly. */#ifndef __SGI_STL_INTERNAL_ALLOC_H#define __SGI_STL_INTERNAL_ALLOC_H#ifdef __SUNPRO_CC# define __PRIVATE public// SUN编译器对private限制过多, 需要开放权限#else# define __PRIVATE private#endif// 为了保证兼容性, 对于不支持模板类静态成员的情况, 使用malloc()进行内存分配#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG# define __USE_MALLOC#endif// 实现了一些标准的node allocator// 但是不同于C++标准或者STL原始STL标准// 这些allocator没有封装不同指针类型// 事实上我们假定只有一种指针理性// allocation primitives意在分配不大于原始STL allocator分配的独立的对象#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#ifndef __ALLOC# define __ALLOC alloc#endif#ifdef __STL_WIN32THREADS# include <windows.h>#endif#include <stddef.h>#include <stdlib.h>#include <string.h>#include <assert.h>#ifndef __RESTRICT# define __RESTRICT#endif// 多线程支持// __STL_PTHREADS // GCC编译器// _NOTHREADS // 不支持多线程// __STL_SGI_THREADS // SGI机器专用// __STL_WIN32THREADS // MSVC编译器#if !defined(__STL_PTHREADS) && !defined(_NOTHREADS) \ && !defined(__STL_SGI_THREADS) && !defined(__STL_WIN32THREADS)# define _NOTHREADS#endif# ifdef __STL_PTHREADS // POSIX Threads // This is dubious, since this is likely to be a high contention // lock. Performance may not be adequate.# include <pthread.h># define __NODE_ALLOCATOR_LOCK \ if (threads) pthread_mutex_lock(&__node_allocator_lock)# define __NODE_ALLOCATOR_UNLOCK \ if (threads) pthread_mutex_unlock(&__node_allocator_lock)# define __NODE_ALLOCATOR_THREADS true# define __VOLATILE volatile // Needed at -O3 on SGI# endif# ifdef __STL_WIN32THREADS // The lock needs to be initialized by constructing an allocator // objects of the right type. We do that here explicitly for alloc.# define __NODE_ALLOCATOR_LOCK \ EnterCriticalSection(&__node_allocator_lock)# define __NODE_ALLOCATOR_UNLOCK \ LeaveCriticalSection(&__node_allocator_lock)# define __NODE_ALLOCATOR_THREADS true# define __VOLATILE volatile // may not be needed# endif /* WIN32THREADS */# ifdef __STL_SGI_THREADS // This should work without threads, with sproc threads, or with // pthreads. It is suboptimal in all cases. // It is unlikely to even compile on nonSGI machines. 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) \ { __lock(&__node_allocator_lock); }# define __NODE_ALLOCATOR_UNLOCK if (threads && __us_rsthread_malloc) \ { __unlock(&__node_allocator_lock); }# define __NODE_ALLOCATOR_THREADS true# define __VOLATILE volatile // Needed at -O3 on SGI# endif# ifdef _NOTHREADS// Thread-unsafe# define __NODE_ALLOCATOR_LOCK# define __NODE_ALLOCATOR_UNLOCK# define __NODE_ALLOCATOR_THREADS false# define __VOLATILE# 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: // 用于在设置了__malloc_alloc_oom_handler情况下循环分配内存, // 直到成功分配 static void *oom_malloc(size_t); static void *oom_realloc(void *, size_t); // 如果编译器支持模板类静态成员, 则使用错误处理函数, 类似C++的set_new_handler() // 默认值为0, 如果不设置, 则内存分配失败时直接__THROW_BAD_ALLOC#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG static void (* __malloc_alloc_oom_handler)();#endifpublic: // 分配指定大小的内存(size_t n), 如果分配失败, 则进入循环分配阶段 // 循环分配前提是要保证正确设置了__malloc_alloc_oom_handler static void * allocate(size_t n) { void *result = malloc(n); if (0 == result) result = oom_malloc(n); return result; } // 后面的size_t是为了兼容operator delele static void deallocate(void *p, size_t /* n */) { free(p); } // 重新分配内存大小, 第二个参数是为了兼容operator new static void * reallocate(void *p, size_t /* old_sz */, size_t new_sz) { void * result = realloc(p, new_sz); if (0 == result) result = oom_realloc(p, new_sz); return result; } // 设置错误处理函数, 返回原来的函数指针 // 不属于C++标准规定的接口 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#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUGtemplate <int inst>void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;#endif// 如果设置了__malloc_alloc_oom_handler, 则首先执行错误处理函数, 然后循环分配直到成功// 如果未设置__malloc_alloc_oom_handler, __THROW_BAD_ALLOCtemplate <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); }}// 这个版本的STL并没有使用non-type模板参数typedef __malloc_alloc_template<0> malloc_alloc;// 这个类中的接口其实就是STL标准中的allocator的接口// 实际上所有的SGI STL都使用这个进行内存配置// 例如: stl_vector.h中// template <class T, class Alloc = alloc>// class vector// {// ...// protected:// typedef simple_alloc<value_type, Alloc> data_allocator;// ...//};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)); }};// 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 {extra = 8}; // Size of space used to store size. Note // that this must be large enough to preserve // alignment.public: // extra 保证不会分配为0的内存空间, 而且要保证内存对齐 // 把分配内存的最前面设置成n的大小, 用于后面校验 // 内存对齐的作用就是保护前面extra大小的数据不被修改 static void * allocate(size_t n) { char *result = (char *)Alloc::allocate(n + extra); *(size_t *)result = n; return result + extra; } // 如果*(size_t *)real_p != n则肯定发生向前越界 static void deallocate(void *p, size_t n) { char * real_p = (char *)p - extra; assert(*(size_t *)real_p == n); Alloc::deallocate(real_p, n + extra); } static void * reallocate(void *p, size_t old_sz, size_t new_sz) { char * real_p = (char *)p - extra; assert(*(size_t *)real_p == old_sz); char * result = (char *) Alloc::reallocate(real_p, old_sz + extra, new_sz + extra); *(size_t *)result = new_sz; return result + extra; }};# ifdef __USE_MALLOCtypedef malloc_alloc alloc;typedef malloc_alloc single_client_alloc;# else// 默认的node allocator// 如果有合适的编译器, 速度上与原始的STL class-specific allocators大致等价// 但是具有产生更少内存碎片的优点// Default_alloc_template参数是用于实验性质的, 在未来可能会消失// 客户只能在当下使用alloc//// 重要的实现属性:// 1. 如果客户请求一个size > __MAX_BYTE的对象, 则直接使用malloc()分配// 2. 对于其它情况下, 我们将请求对象的大小按照内存对齐向上舍入ROUND_UP(requested_size)// TODO: 待翻译// 2. In all other cases, we allocate an object of size exactly// ROUND_UP(requested_size). Thus the client has enough size// information that we can return the object to the proper free list// without permanently losing part of the object.//// 第一个模板参数指定是否有多于一个线程使用本allocator// 在一个default_alloc实例中分配对象, 在另一个deallocate实例中释放对象, 是安全的// 这有效的转换其所有权到另一个对象// 这可能导致对我们引用的区域产生不良影响// 第二个模板参数仅仅用于创建多个default_alloc实例// 不同容器使用不同allocator实例创建的node拥有不同类型, 这限制了此方法的通用性// Sun C++ compiler需要在类外定义这些枚举#ifdef __SUNPRO_CC// breaks if we make these template class members: enum {__ALIGN = 8}; enum {__MAX_BYTES = 128}; enum {__NFREELISTS = __MAX_BYTES/__ALIGN};#endiftemplate <bool threads, int inst>class __default_alloc_template{private: // Really we should use static const int x = N // instead of enum { x = N }, but few compilers accept the former.# ifndef __SUNPRO_CC enum {__ALIGN = 8}; enum {__MAX_BYTES = 128}; enum {__NFREELISTS = __MAX_BYTES/__ALIGN};# endif // 向上舍入操作 // 解释一下, __ALIGN - 1指明的是实际内存对齐的粒度 // 例如__ALIGN = 8时, 我们只需要7就可以实际表示8个数(0~7) // 那么~(__ALIGN - 1)就是进行舍入的粒度 // 我们将(bytes) + __ALIGN-1)就是先进行进位, 然后截断 // 这就保证了我是向上舍入的 // 例如byte = 100, __ALIGN = 8的情况 // ~(__ALIGN - 1) = (1 000)B // ((bytes) + __ALIGN-1) = (1 101 011)B // (((bytes) + __ALIGN-1) & ~(__ALIGN - 1)) = (1 101 000 )B = (104)D // 104 / 8 = 13, 这就实现了向上舍入 // 对于byte刚好满足内存对齐的情况下, 结果保持byte大小不变 // 记得《Hacker's Delight》上面有相关的计算 // 这个表达式与下面给出的等价 // ((((bytes) + _ALIGN - 1) * _ALIGN) / _ALIGN) // 但是SGI STL使用的方法效率非常高 static size_t ROUND_UP(size_t bytes) { return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1)); }__PRIVATE: // 管理内存链表用 // 为了尽最大可能减少内存的使用, 这里使用一个union // 如果使用第一个成员, 则指向另一个相同的union obj // 而如果使用第二个成员, 则指向实际的内存区域 // 这样就实现了链表结点只使用一个指针的大小空间, 却能同时做索引和指向内存区域 // 这个技巧性非常强, 值得学习 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 // 这里分配的free_list为16 // 对应的内存链容量分别为8, 16, 32 ... 128 static obj * __VOLATILE free_list[__NFREELISTS];# endif // 根据待待分配的空间大小, 在free_list中选择合适的大小 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); // 内存池 static char *start_free; // 内存池起始点 static char *end_free; // 内存池结束点 static size_t heap_size; // 已经在堆上分配的空间大小// 下面三个条件编译给多线程条件下使用的锁提供必要支持# ifdef __STL_SGI_THREADS static volatile unsigned long __node_allocator_lock; static void __lock(volatile unsigned long *); static inline void __unlock(volatile unsigned long *);# endif# ifdef __STL_PTHREADS static pthread_mutex_t __node_allocator_lock;# endif# ifdef __STL_WIN32THREADS static CRITICAL_SECTION __node_allocator_lock; static bool __node_allocator_lock_initialized; public: __default_alloc_template() {// This assumes the first constructor is called before threads// are started. if (!__node_allocator_lock_initialized) { InitializeCriticalSection(&__node_allocator_lock); __node_allocator_lock_initialized = true; } } private:# endif // 用于多线程环境下锁定操作用 class lock { public: lock() { __NODE_ALLOCATOR_LOCK; } ~lock() { __NODE_ALLOCATOR_UNLOCK; } }; friend class lock;public: /* n must be > 0 */ static void * allocate(size_t n) { obj * __VOLATILE * my_free_list; obj * __RESTRICT result; // 如果待分配对象大于__MAX_BYTES, 使用一级配置器分配 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); }; /* p may not be 0 */ static void deallocate(void *p, size_t n) { obj *q = (obj *)p; obj * __VOLATILE * my_free_list; // 对于大于__MAX_BYTES的对象, 因为采用的是一级配置器分配, 所以同样使用一级配置器释放 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 } 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>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; // 计算内存池剩余容量 // 如果内存池中剩余内存>=需要分配的内内存, 返回start_free指向的内存块, // 并且重新设置内存池起始点 if (bytes_left >= total_bytes) { result = start_free; start_free += total_bytes; return(result); } // 如果内存吃中剩余的容量不够分配, 但是能至少分配一个节点时, // 返回所能分配的最多的节点, 返回start_free指向的内存块 // 并且重新设置内存池起始点 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); // 将剩余的内存分配给指定的free_list[FREELIST_INDEX(bytes_left)] 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. } } // 再次失败, 直接调用一级配置器分配, 期待异常处理函数能提供帮助 // 不过在我看来, 内存分配失败进行其它尝试已经没什么意义了, // 最好直接log, 然后让程序崩溃 end_free = 0;// In case of exception. start_free = (char *)malloc_alloc::allocate(bytes_to_get); } heap_size += bytes_to_get; end_free = start_free + bytes_to_get; // 内存池更新完毕, 重新分配需要的内存 return(chunk_alloc(size, nobjs)); }}// 返回一个大小为n的对象, 并且加入到free_list[FREELIST_INDEX(n)]// 进行分配操作时, 根据具体环境决定是否加锁// 我们假定要分配的内存满足内存对齐要求template <bool threads, int inst>void* __default_alloc_template<threads, inst>::refill(size_t n){ int nobjs = 20; 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); // 在chunk的空间中建立free_list 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 -> free_list_link = 0; break; } else { current_obj -> 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; // 如果old_size和new_size均大于__MAX_BYTES, 则直接调用realloc() // 因为这部分内存不是经过内存池分配的 if (old_sz > (size_t) __MAX_BYTES && new_sz > (size_t) __MAX_BYTES) { return(realloc(p, new_sz)); } // 如果ROUND_UP(old_sz) == ROUND_UP(new_sz), 内存大小没变化, 不进行重新分配 if (ROUND_UP(old_sz) == 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_PTHREADS template <bool threads, int inst> pthread_mutex_t __default_alloc_template<threads, inst>::__node_allocator_lock = PTHREAD_MUTEX_INITIALIZER;#endif#ifdef __STL_WIN32THREADS template <bool threads, int inst> CRITICAL_SECTION __default_alloc_template<threads, inst>::__node_allocator_lock; template <bool threads, int inst> bool __default_alloc_template<threads, inst>::__node_allocator_lock_initialized= false;#endif#ifdef __STL_SGI_THREADS__STL_END_NAMESPACE#include <mutex.h>#include <time.h>__STL_BEGIN_NAMESPACE// Somewhat generic lock implementations. We need only test-and-set// and some way to sleep. These should work with both SGI pthreads// and sproc threads. They may be useful on other systems.template <bool threads, int inst>volatile unsigned long__default_alloc_template<threads, inst>::__node_allocator_lock = 0;#if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) || defined(__GNUC__)# define __test_and_set(l,v) test_and_set(l,v)#endiftemplate <bool threads, int inst>void__default_alloc_template<threads, inst>::__lock(volatile unsigned long *lock){ const unsigned low_spin_max = 30; // spin cycles if we suspect uniprocessor const unsigned high_spin_max = 1000; // spin cycles for multiprocessor static unsigned spin_max = low_spin_max; unsigned my_spin_max; static unsigned last_spins = 0; unsigned my_last_spins; static struct timespec ts = {0, 1000}; unsigned junk;# define __ALLOC_PAUSE junk *= junk; junk *= junk; junk *= junk; junk *= junk int i; if (!__test_and_set((unsigned long *)lock, 1)) { return; } my_spin_max = spin_max; my_last_spins = last_spins; for (i = 0; i < my_spin_max; i++) { if (i < my_last_spins/2 || *lock) { __ALLOC_PAUSE; continue; } if (!__test_and_set((unsigned long *)lock, 1)) { // got it! // Spinning worked. Thus we're probably not being scheduled // against the other process with which we were contending. // Thus it makes sense to spin longer the next time. last_spins = i; spin_max = high_spin_max; return; } } // We are probably being scheduled against the other process. Sleep. spin_max = low_spin_max; for (;;) { if (!__test_and_set((unsigned long *)lock, 1)) { return; } nanosleep(&ts, 0); }}template <bool threads, int inst>inline void__default_alloc_template<threads, inst>::__unlock(volatile unsigned long *lock){# if defined(__GNUC__) && __mips >= 3 asm("sync"); *lock = 0;# elif __mips >= 3 && (defined (_ABIN32) || defined(_ABI64)) __lock_release(lock);# else *lock = 0; // This is not sufficient on many multiprocessors, since // writes to protected variables and the lock may be reordered.# endif}#endif// 内存池起始位置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, };// The 16 zeros are necessary to make version 4.1 of the SunPro// compiler happy. Otherwise it appears to allocate too little// space for the array.# ifdef __STL_WIN32THREADS // Create one to get critical section initialized. // We do this onece per file, but only the first constructor // does anything. static alloc __node_allocator_dummy_instance;# endif#endif /* ! __USE_MALLOC */#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:
0 0
- 《STL源码剖析》-- stl_alloc.h
- 《STL源码剖析》--stl_alloc.h
- 《STL源码剖析》---stl_alloc.h阅读笔记
- C++ STL源码剖析——stl_alloc.h
- STL源码剖析 [特殊的空间配置器](内存配置stl_alloc.h)
- 《STL源码剖析》-- stl_config.h
- 《STL源码剖析》-- defalloc.h
- 《STL源码剖析》-- stl_construct.h
- 《STL源码剖析》-- stl_uninitialized.h
- 《STL源码剖析》-- stl_iterator.h
- 《STL源码剖析》-- type_traits.h
- 《STL源码剖析》-- stl_vector.h
- 《STL源码剖析》-- stl_pair.h
- 《STL源码剖析》-- stl_list.h
- 《STL源码剖析》-- stl_deque.h
- 《STL源码剖析》-- stl_stack.h
- 《STL源码剖析》-- stl_queue.h
- 《STL源码剖析》-- stl_slist.h
- STL的vector类详解(c++容器类)
- ubuntu下常用命令
- 数据结构--栈和队列
- arm-linux-gnueabihf 交叉编译
- The Mythical Man-Month
- 《STL源码剖析》--stl_alloc.h
- c++模板记录
- Linux网络编程socket错误码分析
- 数据结构--数组和链表
- Linux下关于用户组的一些命令
- 黑马程序员------多线程
- 算法与数据结构笔记三
- LINUX系统移植
- Linux那些事儿 之 戏说USB(19)设备的生命线(二)