1. 程式人生 > >C++ STL原始碼剖析——stl_alloc.h

C++ STL原始碼剖析——stl_alloc.h

stl_alloc.h
# // Comment By:  凝霜  
# // E-mail:      [email protected]  
# // 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)();  
# #endif  
#   
# public:  
#     // 分配指定大小的記憶體(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_BUG  
# template <int inst>  
# void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;  
# #endif  
#   
# // 如果設定了__malloc_alloc_oom_handler, 則首先執行錯誤處理函式, 然後迴圈分配直到成功  
# // 如果未設定__malloc_alloc_oom_handler, __THROW_BAD_ALLOC  
# template <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_MALLOC  
#   
# typedef 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};  
# #endif  
#   
# template <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)  
# #endif  
#   
# template <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:
本文節轉自:http://www.cnblogs.com/lfsblack/archive/2012/11/10/2764334.html