STL 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:
时间: 2024-10-14 03:20:31

STL stl_alloc.h的相关文章

自己动手实现STL 01:内存配置器的实现(stl_alloc.h)

一.前言 在STL中,容器是其中的重中之重,基本的STL中的算法,仿函数等都是围绕着容器实现的功能.而,内存配置器,是容器的实现的基础.所以,我第一次要去编写便是内存配置器的实现.在STL中,内存配置器的实现是在stl_alloc.h中. 二.配置器原理简要介绍 在SGI STL中配置分为两级,第一级配置器和第二级配置器.两者关系如下: 图1:第一级配置器和第二级配置器 在SGI STL中内存的配置器分为两级,第一级配置器和第二级配置器.第一级配置器就是,直接调用系统的malloc分配内存.对于

《STL源码剖析》---stl_alloc.h阅读笔记

这一节是讲空间的配置与释放,但不涉及对象的构造和析构,只是讲解对象构造前空前的申请以及对象析构后空间怎么释放. SGI版本的STL对空间的的申请和释放做了如下考虑: 1.向堆申请空间 2.考虑了多线程.但是这节目的只是讲解空间配置与释放,因此忽略了多线程,集中学习空间的申请和释放. 3.内存不足时的应变措施 4.考虑到了内存碎片的问题.多次申请释放小块内存可能会造成内存碎片. 在C++中,内存的申请和释放是通过operator new函数和operator delete函数,这两个函数相当于C语

stl_alloc.h分配器

五.分配器: 5.1.头文件: 5.1.1.include<stl_alloc.h> //内存的分配. 5.1.2.include<stl_construct.h> //对象的构造和析构. 5.1.3.include<uninitialized.h> //对空间中的内存进行操作. 操作效率高. 5.2.分配,释放: 5.2.1.static void* allocate(size_t __n) //申请获得所需的这段空间,然后返回. { void* __result =

stl_alloc.h

/* * 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 n

STL stl_construct.h

stl_construct.h // Filename: stl_construct.h // Comment By: 凝霜 // E-mail: [email protected] // Blog: http://blog.csdn.net/mdl13412 /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this softw

STL stl_uninitialized.h

stl_uninitialized.h // Filename: stl_uninitialized.h // Comment By: 凝霜 // E-mail: [email protected] // Blog: http://blog.csdn.net/mdl13412 // 主要接口: // // template <class InputIterator, class ForwardIterator> // inline ForwardIterator // uninitialize

STL stl_config.h

stl_config.h 1. // Filename: stl_config.h 2. 3. // Comment By: 凝霜 4. // E-mail: [email protected] 5. // Blog: http://blog.csdn.net/mdl13412 6. 7. /* 8. * Copyright (c) 1996-1997 9. * Silicon Graphics Computer Systems, Inc. 10. * 11. * Permission to u

SGI STL内存配置器存在内存泄漏吗?

阅读了SGI的源码后对STL很是膜拜,很高质量的源码,从中学到了很多.温故而知新!下文中所有STL如无特殊说明均指SGI版本实现. STL 内存配置器 STL对内存管理最核心部分我觉得是其将C++对象创建过程分解为构造.析构和内存分配.释放两类操作分离开来!摆脱了对频繁调用new或malloc函数想操作系统申请空间而造成的低效.其中析构操作时对具有non-trival.trival 析构函数的class区别对待也提高了效率.SGI 的两级配置器结构属于锦上添花. STL内存配置器有没有内存泄漏?

SGI STL内存配置器(一):内存泄漏?

阅读了Alexander大神的SGI STL源码,膜拜,很高质量的源码,获益匪浅.温故而知新!下文中所有STL如无特殊说明均指SGI版本实现. STL 内存配置器 STL对内存管理最核心部分我觉得是它将C++对象创建过程分解为构造.析构和内存分配.释放!摆脱了由于频繁调用new或malloc函数向操作系统申请空间而造成的低效.其中析构操作时对具有non-trival.trival 析构函数的class区别对待也提高了效率.至于SGI的两级配置器结构则属于锦上添花的类型. STL两级结构的内存配置