stl_alloc.h
上传用户:sichengcw
上传日期:2009-02-17
资源大小:202k
文件大小:21k
源码类别:

STL

开发平台:

Visual C++

  1. /*
  2.  * Copyright (c) 1996-1997
  3.  * Silicon Graphics Computer Systems, Inc.
  4.  *
  5.  * Permission to use, copy, modify, distribute and sell this software
  6.  * and its documentation for any purpose is hereby granted without fee,
  7.  * provided that the above copyright notice appear in all copies and
  8.  * that both that copyright notice and this permission notice appear
  9.  * in supporting documentation.  Silicon Graphics makes no
  10.  * representations about the suitability of this software for any
  11.  * purpose.  It is provided "as is" without express or implied warranty.
  12.  */
  13. /* NOTE: This is an internal header file, included by other STL headers.
  14.  *   You should not attempt to use it directly.
  15.  */
  16. #ifndef __SGI_STL_INTERNAL_ALLOC_H
  17. #define __SGI_STL_INTERNAL_ALLOC_H
  18. #ifdef __SUNPRO_CC
  19. #  define __PRIVATE public
  20.    // Extra access restrictions prevent us from really making some things
  21.    // private.
  22. #else
  23. #  define __PRIVATE private
  24. #endif
  25. #ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
  26. #  define __USE_MALLOC
  27. #endif
  28. // This implements some standard node allocators.  These are
  29. // NOT the same as the allocators in the C++ draft standard or in
  30. // in the original STL.  They do not encapsulate different pointer
  31. // types; indeed we assume that there is only one pointer type.
  32. // The allocation primitives are intended to allocate individual objects,
  33. // not larger arenas as with the original STL allocators.
  34. #if 0
  35. #   include <new>
  36. #   define __THROW_BAD_ALLOC throw bad_alloc
  37. #elif !defined(__THROW_BAD_ALLOC)
  38. #   include <iostream.h>
  39. #   define __THROW_BAD_ALLOC cerr << "out of memory" << endl; exit(1)
  40. #endif
  41. #ifndef __ALLOC
  42. #   define __ALLOC alloc
  43. #endif
  44. #ifdef __STL_WIN32THREADS
  45. #   include <windows.h>
  46. #endif
  47. #include <stddef.h>
  48. #include <stdlib.h>
  49. #include <string.h>
  50. #include <assert.h>
  51. #ifndef __RESTRICT
  52. #  define __RESTRICT
  53. #endif
  54. #if !defined(__STL_PTHREADS) && !defined(_NOTHREADS) 
  55.  && !defined(__STL_SGI_THREADS) && !defined(__STL_WIN32THREADS)
  56. #   define _NOTHREADS
  57. #endif
  58. # ifdef __STL_PTHREADS
  59.     // POSIX Threads
  60.     // This is dubious, since this is likely to be a high contention
  61.     // lock.   Performance may not be adequate.
  62. #   include <pthread.h>
  63. #   define __NODE_ALLOCATOR_LOCK 
  64.         if (threads) pthread_mutex_lock(&__node_allocator_lock)
  65. #   define __NODE_ALLOCATOR_UNLOCK 
  66.         if (threads) pthread_mutex_unlock(&__node_allocator_lock)
  67. #   define __NODE_ALLOCATOR_THREADS true
  68. #   define __VOLATILE volatile  // Needed at -O3 on SGI
  69. # endif
  70. # ifdef __STL_WIN32THREADS
  71.     // The lock needs to be initialized by constructing an allocator
  72.     // objects of the right type.  We do that here explicitly for alloc.
  73. #   define __NODE_ALLOCATOR_LOCK 
  74.         EnterCriticalSection(&__node_allocator_lock)
  75. #   define __NODE_ALLOCATOR_UNLOCK 
  76.         LeaveCriticalSection(&__node_allocator_lock)
  77. #   define __NODE_ALLOCATOR_THREADS true
  78. #   define __VOLATILE volatile  // may not be needed
  79. # endif /* WIN32THREADS */
  80. # ifdef __STL_SGI_THREADS
  81.     // This should work without threads, with sproc threads, or with
  82.     // pthreads.  It is suboptimal in all cases.
  83.     // It is unlikely to even compile on nonSGI machines.
  84.     extern "C" {
  85.       extern int __us_rsthread_malloc;
  86.     }
  87. // The above is copied from malloc.h.  Including <malloc.h>
  88. // would be cleaner but fails with certain levels of standard
  89. // conformance.
  90. #   define __NODE_ALLOCATOR_LOCK if (threads && __us_rsthread_malloc) 
  91.                 { __lock(&__node_allocator_lock); }
  92. #   define __NODE_ALLOCATOR_UNLOCK if (threads && __us_rsthread_malloc) 
  93.                 { __unlock(&__node_allocator_lock); }
  94. #   define __NODE_ALLOCATOR_THREADS true
  95. #   define __VOLATILE volatile  // Needed at -O3 on SGI
  96. # endif
  97. # ifdef _NOTHREADS
  98. //  Thread-unsafe
  99. #   define __NODE_ALLOCATOR_LOCK
  100. #   define __NODE_ALLOCATOR_UNLOCK
  101. #   define __NODE_ALLOCATOR_THREADS false
  102. #   define __VOLATILE
  103. # endif
  104. __STL_BEGIN_NAMESPACE
  105. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  106. #pragma set woff 1174
  107. #endif
  108. // Malloc-based allocator.  Typically slower than default alloc below.
  109. // Typically thread-safe and more storage efficient.
  110. #ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
  111. # ifdef __DECLARE_GLOBALS_HERE
  112.     void (* __malloc_alloc_oom_handler)() = 0;
  113.     // g++ 2.7.2 does not handle static template data members.
  114. # else
  115.     extern void (* __malloc_alloc_oom_handler)();
  116. # endif
  117. #endif
  118. template <int inst>
  119. class __malloc_alloc_template {
  120. private:
  121. static void *oom_malloc(size_t);
  122. static void *oom_realloc(void *, size_t);
  123. #ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
  124.     static void (* __malloc_alloc_oom_handler)();
  125. #endif
  126. public:
  127. static void * allocate(size_t n)
  128. {
  129.     void *result = malloc(n);
  130.     if (0 == result) result = oom_malloc(n);
  131.     return result;
  132. }
  133. static void deallocate(void *p, size_t /* n */)
  134. {
  135.     free(p);
  136. }
  137. static void * reallocate(void *p, size_t /* old_sz */, size_t new_sz)
  138. {
  139.     void * result = realloc(p, new_sz);
  140.     if (0 == result) result = oom_realloc(p, new_sz);
  141.     return result;
  142. }
  143. static void (* set_malloc_handler(void (*f)()))()
  144. {
  145.     void (* old)() = __malloc_alloc_oom_handler;
  146.     __malloc_alloc_oom_handler = f;
  147.     return(old);
  148. }
  149. };
  150. // malloc_alloc out-of-memory handling
  151. #ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
  152. template <int inst>
  153. void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;
  154. #endif
  155. template <int inst>
  156. void * __malloc_alloc_template<inst>::oom_malloc(size_t n)
  157. {
  158.     void (* my_malloc_handler)();
  159.     void *result;
  160.     for (;;) {
  161.         my_malloc_handler = __malloc_alloc_oom_handler;
  162.         if (0 == my_malloc_handler) { __THROW_BAD_ALLOC; }
  163.         (*my_malloc_handler)();
  164.         result = malloc(n);
  165.         if (result) return(result);
  166.     }
  167. }
  168. template <int inst>
  169. void * __malloc_alloc_template<inst>::oom_realloc(void *p, size_t n)
  170. {
  171.     void (* my_malloc_handler)();
  172.     void *result;
  173.     for (;;) {
  174.         my_malloc_handler = __malloc_alloc_oom_handler;
  175.         if (0 == my_malloc_handler) { __THROW_BAD_ALLOC; }
  176.         (*my_malloc_handler)();
  177.         result = realloc(p, n);
  178.         if (result) return(result);
  179.     }
  180. }
  181. typedef __malloc_alloc_template<0> malloc_alloc;
  182. template<class T, class Alloc>
  183. class simple_alloc {
  184. public:
  185.     static T *allocate(size_t n)
  186.                 { return 0 == n? 0 : (T*) Alloc::allocate(n * sizeof (T)); }
  187.     static T *allocate(void)
  188.                 { return (T*) Alloc::allocate(sizeof (T)); }
  189.     static void deallocate(T *p, size_t n)
  190.                 { if (0 != n) Alloc::deallocate(p, n * sizeof (T)); }
  191.     static void deallocate(T *p)
  192.                 { Alloc::deallocate(p, sizeof (T)); }
  193. };
  194. // Allocator adaptor to check size arguments for debugging.
  195. // Reports errors using assert.  Checking can be disabled with
  196. // NDEBUG, but it's far better to just use the underlying allocator
  197. // instead when no checking is desired.
  198. // There is some evidence that this can confuse Purify.
  199. template <class Alloc>
  200. class debug_alloc {
  201. private:
  202. enum {extra = 8};       // Size of space used to store size.  Note
  203.                         // that this must be large enough to preserve
  204.                         // alignment.
  205. public:
  206. static void * allocate(size_t n)
  207. {
  208.     char *result = (char *)Alloc::allocate(n + extra);
  209.     *(size_t *)result = n;
  210.     return result + extra;
  211. }
  212. static void deallocate(void *p, size_t n)
  213. {
  214.     char * real_p = (char *)p - extra;
  215.     assert(*(size_t *)real_p == n);
  216.     Alloc::deallocate(real_p, n + extra);
  217. }
  218. static void * reallocate(void *p, size_t old_sz, size_t new_sz)
  219. {
  220.     char * real_p = (char *)p - extra;
  221.     assert(*(size_t *)real_p == old_sz);
  222.     char * result = (char *)
  223.                   Alloc::reallocate(real_p, old_sz + extra, new_sz + extra);
  224.     *(size_t *)result = new_sz;
  225.     return result + extra;
  226. }
  227. };
  228. # ifdef __USE_MALLOC
  229. typedef malloc_alloc alloc;
  230. typedef malloc_alloc single_client_alloc;
  231. # else
  232. // Default node allocator.
  233. // With a reasonable compiler, this should be roughly as fast as the
  234. // original STL class-specific allocators, but with less fragmentation.
  235. // Default_alloc_template parameters are experimental and MAY
  236. // DISAPPEAR in the future.  Clients should just use alloc for now.
  237. //
  238. // Important implementation properties:
  239. // 1. If the client request an object of size > __MAX_BYTES, the resulting
  240. //    object will be obtained directly from malloc.
  241. // 2. In all other cases, we allocate an object of size exactly
  242. //    ROUND_UP(requested_size).  Thus the client has enough size
  243. //    information that we can return the object to the proper free list
  244. //    without permanently losing part of the object.
  245. //
  246. // The first template parameter specifies whether more than one thread
  247. // may use this allocator.  It is safe to allocate an object from
  248. // one instance of a default_alloc and deallocate it with another
  249. // one.  This effectively transfers its ownership to the second one.
  250. // This may have undesirable effects on reference locality.
  251. // The second parameter is unreferenced and serves only to allow the
  252. // creation of multiple default_alloc instances.
  253. // Node that containers built on different allocator instances have
  254. // different types, limiting the utility of this approach.
  255. #ifdef __SUNPRO_CC
  256. // breaks if we make these template class members:
  257.   enum {__ALIGN = 8};
  258.   enum {__MAX_BYTES = 128};
  259.   enum {__NFREELISTS = __MAX_BYTES/__ALIGN};
  260. #endif
  261. template <bool threads, int inst>
  262. class __default_alloc_template {
  263. private:
  264.   // Really we should use static const int x = N
  265.   // instead of enum { x = N }, but few compilers accept the former.
  266. # ifndef __SUNPRO_CC
  267.     enum {__ALIGN = 8};
  268.     enum {__MAX_BYTES = 128};
  269.     enum {__NFREELISTS = __MAX_BYTES/__ALIGN};
  270. # endif
  271.   static size_t ROUND_UP(size_t bytes) {
  272.         return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
  273.   }
  274. __PRIVATE:
  275.   union obj {
  276.         union obj * free_list_link;
  277.         char client_data[1];    /* The client sees this.        */
  278.   };
  279. private:
  280. # ifdef __SUNPRO_CC
  281.     static obj * __VOLATILE free_list[]; 
  282.         // Specifying a size results in duplicate def for 4.1
  283. # else
  284.     static obj * __VOLATILE free_list[__NFREELISTS]; 
  285. # endif
  286.   static  size_t FREELIST_INDEX(size_t bytes) {
  287.         return (((bytes) + __ALIGN-1)/__ALIGN - 1);
  288.   }
  289.   // Returns an object of size n, and optionally adds to size n free list.
  290.   static void *refill(size_t n);
  291.   // Allocates a chunk for nobjs of size "size".  nobjs may be reduced
  292.   // if it is inconvenient to allocate the requested number.
  293.   static char *chunk_alloc(size_t size, int &nobjs);
  294.   // Chunk allocation state.
  295.   static char *start_free;
  296.   static char *end_free;
  297.   static size_t heap_size;
  298. # ifdef __STL_SGI_THREADS
  299.     static volatile unsigned long __node_allocator_lock;
  300.     static void __lock(volatile unsigned long *); 
  301.     static inline void __unlock(volatile unsigned long *);
  302. # endif
  303. # ifdef __STL_PTHREADS
  304.     static pthread_mutex_t __node_allocator_lock;
  305. # endif
  306. # ifdef __STL_WIN32THREADS
  307.     static CRITICAL_SECTION __node_allocator_lock;
  308.     static bool __node_allocator_lock_initialized;
  309.   public:
  310.     __default_alloc_template() {
  311. // This assumes the first constructor is called before threads
  312. // are started.
  313.         if (!__node_allocator_lock_initialized) {
  314.             InitializeCriticalSection(&__node_allocator_lock);
  315.             __node_allocator_lock_initialized = true;
  316.         }
  317.     }
  318.   private:
  319. # endif
  320.     class lock {
  321.         public:
  322.             lock() { __NODE_ALLOCATOR_LOCK; }
  323.             ~lock() { __NODE_ALLOCATOR_UNLOCK; }
  324.     };
  325.     friend class lock;
  326. public:
  327.   /* n must be > 0      */
  328.   static void * allocate(size_t n)
  329.   {
  330.     obj * __VOLATILE * my_free_list;
  331.     obj * __RESTRICT result;
  332.     if (n > (size_t) __MAX_BYTES) {
  333.         return(malloc_alloc::allocate(n));
  334.     }
  335.     my_free_list = free_list + FREELIST_INDEX(n);
  336.     // Acquire the lock here with a constructor call.
  337.     // This ensures that it is released in exit or during stack
  338.     // unwinding.
  339. #       ifndef _NOTHREADS
  340.         /*REFERENCED*/
  341.         lock lock_instance;
  342. #       endif
  343.     result = *my_free_list;
  344.     if (result == 0) {
  345.         void *r = refill(ROUND_UP(n));
  346.         return r;
  347.     }
  348.     *my_free_list = result -> free_list_link;
  349.     return (result);
  350.   };
  351.   /* p may not be 0 */
  352.   static void deallocate(void *p, size_t n)
  353.   {
  354.     obj *q = (obj *)p;
  355.     obj * __VOLATILE * my_free_list;
  356.     if (n > (size_t) __MAX_BYTES) {
  357.         malloc_alloc::deallocate(p, n);
  358.         return;
  359.     }
  360.     my_free_list = free_list + FREELIST_INDEX(n);
  361.     // acquire lock
  362. #       ifndef _NOTHREADS
  363.         /*REFERENCED*/
  364.         lock lock_instance;
  365. #       endif /* _NOTHREADS */
  366.     q -> free_list_link = *my_free_list;
  367.     *my_free_list = q;
  368.     // lock is released here
  369.   }
  370.   static void * reallocate(void *p, size_t old_sz, size_t new_sz);
  371. } ;
  372. typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
  373. typedef __default_alloc_template<false, 0> single_client_alloc;
  374. /* We allocate memory in large chunks in order to avoid fragmenting     */
  375. /* the malloc heap too much.                                            */
  376. /* We assume that size is properly aligned.                             */
  377. /* We hold the allocation lock.                                         */
  378. template <bool threads, int inst>
  379. char*
  380. __default_alloc_template<threads, inst>::chunk_alloc(size_t size, int& nobjs)
  381. {
  382.     char * result;
  383.     size_t total_bytes = size * nobjs;
  384.     size_t bytes_left = end_free - start_free;
  385.     if (bytes_left >= total_bytes) {
  386.         result = start_free;
  387.         start_free += total_bytes;
  388.         return(result);
  389.     } else if (bytes_left >= size) {
  390.         nobjs = bytes_left/size;
  391.         total_bytes = size * nobjs;
  392.         result = start_free;
  393.         start_free += total_bytes;
  394.         return(result);
  395.     } else {
  396.         size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
  397.         // Try to make use of the left-over piece.
  398.         if (bytes_left > 0) {
  399.             obj * __VOLATILE * my_free_list =
  400.                         free_list + FREELIST_INDEX(bytes_left);
  401.             ((obj *)start_free) -> free_list_link = *my_free_list;
  402.             *my_free_list = (obj *)start_free;
  403.         }
  404.         start_free = (char *)malloc(bytes_to_get);
  405.         if (0 == start_free) {
  406.             int i;
  407.             obj * __VOLATILE * my_free_list, *p;
  408.             // Try to make do with what we have.  That can't
  409.             // hurt.  We do not try smaller requests, since that tends
  410.             // to result in disaster on multi-process machines.
  411.             for (i = size; i <= __MAX_BYTES; i += __ALIGN) {
  412.                 my_free_list = free_list + FREELIST_INDEX(i);
  413.                 p = *my_free_list;
  414.                 if (0 != p) {
  415.                     *my_free_list = p -> free_list_link;
  416.                     start_free = (char *)p;
  417.                     end_free = start_free + i;
  418.                     return(chunk_alloc(size, nobjs));
  419.                     // Any leftover piece will eventually make it to the
  420.                     // right free list.
  421.                 }
  422.             }
  423.     end_free = 0; // In case of exception.
  424.             start_free = (char *)malloc_alloc::allocate(bytes_to_get);
  425.             // This should either throw an
  426.             // exception or remedy the situation.  Thus we assume it
  427.             // succeeded.
  428.         }
  429.         heap_size += bytes_to_get;
  430.         end_free = start_free + bytes_to_get;
  431.         return(chunk_alloc(size, nobjs));
  432.     }
  433. }
  434. /* Returns an object of size n, and optionally adds to size n free list.*/
  435. /* We assume that n is properly aligned.                                */
  436. /* We hold the allocation lock.                                         */
  437. template <bool threads, int inst>
  438. void* __default_alloc_template<threads, inst>::refill(size_t n)
  439. {
  440.     int nobjs = 20;
  441.     char * chunk = chunk_alloc(n, nobjs);
  442.     obj * __VOLATILE * my_free_list;
  443.     obj * result;
  444.     obj * current_obj, * next_obj;
  445.     int i;
  446.     if (1 == nobjs) return(chunk);
  447.     my_free_list = free_list + FREELIST_INDEX(n);
  448.     /* Build free list in chunk */
  449.       result = (obj *)chunk;
  450.       *my_free_list = next_obj = (obj *)(chunk + n);
  451.       for (i = 1; ; i++) {
  452.         current_obj = next_obj;
  453.         next_obj = (obj *)((char *)next_obj + n);
  454.         if (nobjs - 1 == i) {
  455.             current_obj -> free_list_link = 0;
  456.             break;
  457.         } else {
  458.             current_obj -> free_list_link = next_obj;
  459.         }
  460.       }
  461.     return(result);
  462. }
  463. template <bool threads, int inst>
  464. void*
  465. __default_alloc_template<threads, inst>::reallocate(void *p,
  466.                                                     size_t old_sz,
  467.                                                     size_t new_sz)
  468. {
  469.     void * result;
  470.     size_t copy_sz;
  471.     if (old_sz > (size_t) __MAX_BYTES && new_sz > (size_t) __MAX_BYTES) {
  472.         return(realloc(p, new_sz));
  473.     }
  474.     if (ROUND_UP(old_sz) == ROUND_UP(new_sz)) return(p);
  475.     result = allocate(new_sz);
  476.     copy_sz = new_sz > old_sz? old_sz : new_sz;
  477.     memcpy(result, p, copy_sz);
  478.     deallocate(p, old_sz);
  479.     return(result);
  480. }
  481. #ifdef __STL_PTHREADS
  482.     template <bool threads, int inst>
  483.     pthread_mutex_t
  484.     __default_alloc_template<threads, inst>::__node_allocator_lock
  485.         = PTHREAD_MUTEX_INITIALIZER;
  486. #endif
  487. #ifdef __STL_WIN32THREADS
  488.     template <bool threads, int inst> CRITICAL_SECTION
  489.     __default_alloc_template<threads, inst>::__node_allocator_lock;
  490.     template <bool threads, int inst> bool
  491.     __default_alloc_template<threads, inst>::__node_allocator_lock_initialized
  492. = false;
  493. #endif
  494. #ifdef __STL_SGI_THREADS
  495. __STL_END_NAMESPACE
  496. #include <mutex.h>
  497. #include <time.h>
  498. __STL_BEGIN_NAMESPACE
  499. // Somewhat generic lock implementations.  We need only test-and-set
  500. // and some way to sleep.  These should work with both SGI pthreads
  501. // and sproc threads.  They may be useful on other systems.
  502. template <bool threads, int inst>
  503. volatile unsigned long
  504. __default_alloc_template<threads, inst>::__node_allocator_lock = 0;
  505. #if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) || defined(__GNUC__)
  506. #   define __test_and_set(l,v) test_and_set(l,v)
  507. #endif
  508. template <bool threads, int inst>
  509. void 
  510. __default_alloc_template<threads, inst>::__lock(volatile unsigned long *lock)
  511. {
  512.     const unsigned low_spin_max = 30;  // spin cycles if we suspect uniprocessor
  513.     const unsigned high_spin_max = 1000; // spin cycles for multiprocessor
  514.     static unsigned spin_max = low_spin_max;
  515.     unsigned my_spin_max;
  516.     static unsigned last_spins = 0;
  517.     unsigned my_last_spins;
  518.     static struct timespec ts = {0, 1000};
  519.     unsigned junk;
  520. #   define __ALLOC_PAUSE junk *= junk; junk *= junk; junk *= junk; junk *= junk
  521.     int i;
  522.     if (!__test_and_set((unsigned long *)lock, 1)) {
  523.         return;
  524.     }
  525.     my_spin_max = spin_max;
  526.     my_last_spins = last_spins;
  527.     for (i = 0; i < my_spin_max; i++) {
  528.         if (i < my_last_spins/2 || *lock) {
  529.             __ALLOC_PAUSE;
  530.             continue;
  531.         }
  532.         if (!__test_and_set((unsigned long *)lock, 1)) {
  533.             // got it!
  534.             // Spinning worked.  Thus we're probably not being scheduled
  535.             // against the other process with which we were contending.
  536.             // Thus it makes sense to spin longer the next time.
  537.             last_spins = i;
  538.             spin_max = high_spin_max;
  539.             return;
  540.         }
  541.     }
  542.     // We are probably being scheduled against the other process.  Sleep.
  543.     spin_max = low_spin_max;
  544.     for (;;) {
  545.         if (!__test_and_set((unsigned long *)lock, 1)) {
  546.             return;
  547.         }
  548.         nanosleep(&ts, 0);
  549.     }
  550. }
  551. template <bool threads, int inst>
  552. inline void
  553. __default_alloc_template<threads, inst>::__unlock(volatile unsigned long *lock)
  554. {
  555. #   if defined(__GNUC__) && __mips >= 3
  556.         asm("sync");
  557.         *lock = 0;
  558. #   elif __mips >= 3 && (defined (_ABIN32) || defined(_ABI64))
  559.         __lock_release(lock);
  560. #   else 
  561.         *lock = 0;
  562.         // This is not sufficient on many multiprocessors, since
  563.         // writes to protected variables and the lock may be reordered.
  564. #   endif
  565. }
  566. #endif
  567. template <bool threads, int inst>
  568. char *__default_alloc_template<threads, inst>::start_free = 0;
  569. template <bool threads, int inst>
  570. char *__default_alloc_template<threads, inst>::end_free = 0;
  571. template <bool threads, int inst>
  572. size_t __default_alloc_template<threads, inst>::heap_size = 0;
  573. template <bool threads, int inst>
  574. __default_alloc_template<threads, inst>::obj * __VOLATILE
  575. __default_alloc_template<threads, inst> ::free_list[
  576. # ifdef __SUNPRO_CC
  577.     __NFREELISTS
  578. # else
  579.     __default_alloc_template<threads, inst>::__NFREELISTS
  580. # endif
  581. ] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
  582. // The 16 zeros are necessary to make version 4.1 of the SunPro
  583. // compiler happy.  Otherwise it appears to allocate too little
  584. // space for the array.
  585. # ifdef __STL_WIN32THREADS
  586.   // Create one to get critical section initialized.
  587.   // We do this onece per file, but only the first constructor
  588.   // does anything.
  589.   static alloc __node_allocator_dummy_instance;
  590. # endif
  591. #endif /* ! __USE_MALLOC */
  592. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  593. #pragma reset woff 1174
  594. #endif
  595. __STL_END_NAMESPACE
  596. #undef __PRIVATE
  597. #endif /* __SGI_STL_INTERNAL_ALLOC_H */
  598. // Local Variables:
  599. // mode:C++
  600. // End: