michael@0: /*
michael@0:  *
michael@0:  * Copyright (c) 1996,1997
michael@0:  * Silicon Graphics Computer Systems, Inc.
michael@0:  *
michael@0:  * Copyright (c) 1997
michael@0:  * Moscow Center for SPARC Technology
michael@0:  *
michael@0:  * Copyright (c) 1999
michael@0:  * Boris Fomitchev
michael@0:  *
michael@0:  * This material is provided "as is", with absolutely no warranty expressed
michael@0:  * or implied. Any use is at your own risk.
michael@0:  *
michael@0:  * Permission to use or copy this software for any purpose is hereby granted
michael@0:  * without fee, provided the above notices are retained on all copies.
michael@0:  * Permission to modify the code and to distribute modified code is granted,
michael@0:  * provided the above notices are retained, and a notice that the code was
michael@0:  * modified is included with the above copyright notice.
michael@0:  *
michael@0:  */
michael@0: 
michael@0: #include "stlport_prefix.h"
michael@0: 
michael@0: #include <memory>
michael@0: 
michael@0: #if defined (__GNUC__) && (defined (__CYGWIN__) || defined (__MINGW32__))
michael@0: #  include <malloc.h>
michael@0: #endif
michael@0: 
michael@0: #if defined (_STLP_PTHREADS) && !defined (_STLP_NO_THREADS)
michael@0: #  include <pthread_alloc>
michael@0: #  include <cerrno>
michael@0: #endif
michael@0: 
michael@0: #include <stl/_threads.h>
michael@0: 
michael@0: #include "lock_free_slist.h"
michael@0: 
michael@0: #if defined (__WATCOMC__)
michael@0: #  pragma warning 13 9
michael@0: #  pragma warning 367 9
michael@0: #  pragma warning 368 9
michael@0: #endif
michael@0: 
michael@0: #if defined (_STLP_SGI_THREADS)
michael@0:   // We test whether threads are in use before locking.
michael@0:   // Perhaps this should be moved into stl_threads.h, but that
michael@0:   // probably makes it harder to avoid the procedure call when
michael@0:   // it isn't needed.
michael@0: extern "C" {
michael@0:   extern int __us_rsthread_malloc;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: // Specialised debug form of new operator which does not provide "false"
michael@0: // memory leaks when run with debug CRT libraries.
michael@0: #if defined (_STLP_MSVC) && (_STLP_MSVC >= 1020 && defined (_STLP_DEBUG_ALLOC)) && !defined (_STLP_WCE)
michael@0: #  include <crtdbg.h>
michael@0: inline char* __stlp_new_chunk(size_t __bytes) {
michael@0:   void *__chunk = _STLP_CHECK_NULL_ALLOC(::operator new(__bytes, __FILE__, __LINE__));
michael@0:   return __STATIC_CAST(char*, __chunk);
michael@0: }
michael@0: inline void __stlp_delete_chunck(void* __p) { ::operator delete(__p, __FILE__, __LINE__); }
michael@0: #else
michael@0: #  ifdef _STLP_NODE_ALLOC_USE_MALLOC
michael@0: #    include <cstdlib>
michael@0: inline char* __stlp_new_chunk(size_t __bytes) {
michael@0:   // do not use _STLP_CHECK_NULL_ALLOC, this macro is dedicated to new operator.
michael@0:   void *__chunk = _STLP_VENDOR_CSTD::malloc(__bytes);
michael@0:   if (__chunk == 0) {
michael@0:     _STLP_THROW_BAD_ALLOC;
michael@0:   }
michael@0:   return __STATIC_CAST(char*, __chunk);
michael@0: }
michael@0: inline void __stlp_delete_chunck(void* __p) { _STLP_VENDOR_CSTD::free(__p); }
michael@0: #  else
michael@0: inline char* __stlp_new_chunk(size_t __bytes)
michael@0: { return __STATIC_CAST(char*, _STLP_STD::__stl_new(__bytes)); }
michael@0: inline void __stlp_delete_chunck(void* __p) { _STLP_STD::__stl_delete(__p); }
michael@0: #  endif
michael@0: #endif
michael@0: 
michael@0: /* This is an additional atomic operations to the ones already defined in
michael@0:  * stl/_threads.h, platform should try to support it to improve performance.
michael@0:  * __add_atomic_t _STLP_ATOMIC_ADD(volatile __add_atomic_t* __target, __add_atomic_t __val) :
michael@0:  * does *__target = *__target + __val and returns the old *__target value */
michael@0: typedef long __add_atomic_t;
michael@0: typedef unsigned long __uadd_atomic_t;
michael@0: 
michael@0: #if defined (__GNUC__) && defined (__i386__)
michael@0: inline long _STLP_atomic_add_gcc_x86(long volatile* p, long addend) {
michael@0:   long result;
michael@0:   __asm__ __volatile__
michael@0:     ("lock; xaddl %1, %0;"
michael@0:     :"=m" (*p), "=r" (result)
michael@0:     :"m"  (*p), "1"  (addend)
michael@0:     :"cc");
michael@0:  return result + addend;
michael@0: }
michael@0: #  define _STLP_ATOMIC_ADD(__dst, __val)  _STLP_atomic_add_gcc_x86(__dst, __val)
michael@0: #elif defined (_STLP_WIN32THREADS)
michael@0: // The Win32 API function InterlockedExchangeAdd is not available on Windows 95.
michael@0: #  if !defined (_STLP_WIN95_LIKE)
michael@0: #    if defined (_STLP_NEW_PLATFORM_SDK)
michael@0: #      define _STLP_ATOMIC_ADD(__dst, __val) InterlockedExchangeAdd(__dst, __val)
michael@0: #    else
michael@0: #      define _STLP_ATOMIC_ADD(__dst, __val) InterlockedExchangeAdd(__CONST_CAST(__add_atomic_t*, __dst), __val)
michael@0: #    endif
michael@0: #  endif
michael@0: #endif
michael@0: 
michael@0: #if defined (__OS400__)
michael@0: // dums 02/05/2007: is it really necessary ?
michael@0: enum { _ALIGN = 16, _ALIGN_SHIFT = 4 };
michael@0: #else
michael@0: enum { _ALIGN = 2 * sizeof(void*), _ALIGN_SHIFT = 2 + sizeof(void*) / 4 };
michael@0: #endif
michael@0: 
michael@0: #define _S_FREELIST_INDEX(__bytes) ((__bytes - size_t(1)) >> (int)_ALIGN_SHIFT)
michael@0: 
michael@0: _STLP_BEGIN_NAMESPACE
michael@0: 
michael@0: // malloc_alloc out-of-memory handling
michael@0: static __oom_handler_type __oom_handler = __STATIC_CAST(__oom_handler_type, 0);
michael@0: 
michael@0: #ifdef _STLP_THREADS
michael@0: _STLP_mutex __oom_handler_lock;
michael@0: #endif
michael@0: 
michael@0: void* _STLP_CALL __malloc_alloc::allocate(size_t __n)
michael@0: {
michael@0:   void *__result = malloc(__n);
michael@0:   if ( 0 == __result ) {
michael@0:     __oom_handler_type __my_malloc_handler;
michael@0: 
michael@0:     for (;;) {
michael@0:       {
michael@0: #ifdef _STLP_THREADS
michael@0:         _STLP_auto_lock _l( __oom_handler_lock );
michael@0: #endif
michael@0:         __my_malloc_handler = __oom_handler;
michael@0:       }
michael@0:       if ( 0 == __my_malloc_handler) {
michael@0:         _STLP_THROW_BAD_ALLOC;
michael@0:       }
michael@0:       (*__my_malloc_handler)();
michael@0:       __result = malloc(__n);
michael@0:       if ( __result )
michael@0:         return __result;
michael@0:     }
michael@0:   }
michael@0:   return __result;
michael@0: }
michael@0: 
michael@0: __oom_handler_type _STLP_CALL __malloc_alloc::set_malloc_handler(__oom_handler_type __f)
michael@0: {
michael@0: #ifdef _STLP_THREADS
michael@0:   _STLP_auto_lock _l( __oom_handler_lock );
michael@0: #endif
michael@0:   __oom_handler_type __old = __oom_handler;
michael@0:   __oom_handler = __f;
michael@0:   return __old;
michael@0: }
michael@0: 
michael@0: // *******************************************************
michael@0: // Default node allocator.
michael@0: // With a reasonable compiler, this should be roughly as fast as the
michael@0: // original STL class-specific allocators, but with less fragmentation.
michael@0: //
michael@0: // Important implementation properties:
michael@0: // 1. If the client request an object of size > _MAX_BYTES, the resulting
michael@0: //    object will be obtained directly from malloc.
michael@0: // 2. In all other cases, we allocate an object of size exactly
michael@0: //    _S_round_up(requested_size).  Thus the client has enough size
michael@0: //    information that we can return the object to the proper free list
michael@0: //    without permanently losing part of the object.
michael@0: //
michael@0: 
michael@0: #define _STLP_NFREELISTS 16
michael@0: 
michael@0: #if defined (_STLP_LEAKS_PEDANTIC) && defined (_STLP_USE_DYNAMIC_LIB)
michael@0: /*
michael@0:  * We can only do cleanup of the node allocator memory pool if we are
michael@0:  * sure that the STLport library is used as a shared one as it guaranties
michael@0:  * the unicity of the node allocator instance. Without that guaranty node
michael@0:  * allocator instances might exchange memory blocks making the implementation
michael@0:  * of a cleaning process much more complicated.
michael@0:  */
michael@0: #  define _STLP_DO_CLEAN_NODE_ALLOC
michael@0: #endif
michael@0: 
michael@0: /* When STLport is used without multi threaded safety we use the node allocator
michael@0:  * implementation with locks as locks becomes no-op. The lock free implementation
michael@0:  * always use system specific atomic operations which are slower than 'normal'
michael@0:  * ones.
michael@0:  */
michael@0: #if defined (_STLP_THREADS) && \
michael@0:     defined (_STLP_HAS_ATOMIC_FREELIST) && defined (_STLP_ATOMIC_ADD)
michael@0: /*
michael@0:  * We have an implementation of the atomic freelist (_STLP_atomic_freelist)
michael@0:  * for this architecture and compiler.  That means we can use the non-blocking
michael@0:  * implementation of the node-allocation engine.*/
michael@0: #  define _STLP_USE_LOCK_FREE_IMPLEMENTATION
michael@0: #endif
michael@0: 
michael@0: #if !defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0: #  if defined (_STLP_THREADS)
michael@0: 
michael@0: class _Node_Alloc_Lock {
michael@0:   static _STLP_STATIC_MUTEX& _S_Mutex() {
michael@0:     static _STLP_STATIC_MUTEX mutex _STLP_MUTEX_INITIALIZER;
michael@0:     return mutex;
michael@0:   }
michael@0: public:
michael@0:   _Node_Alloc_Lock() {
michael@0: #    if defined (_STLP_SGI_THREADS)
michael@0:     if (__us_rsthread_malloc)
michael@0: #    endif
michael@0:       _S_Mutex()._M_acquire_lock();
michael@0:   }
michael@0: 
michael@0:   ~_Node_Alloc_Lock() {
michael@0: #    if defined (_STLP_SGI_THREADS)
michael@0:     if (__us_rsthread_malloc)
michael@0: #    endif
michael@0:       _S_Mutex()._M_release_lock();
michael@0:   }
michael@0: };
michael@0: 
michael@0: #  else
michael@0: 
michael@0: class _Node_Alloc_Lock {
michael@0: public:
michael@0:   _Node_Alloc_Lock() { }
michael@0:   ~_Node_Alloc_Lock() { }
michael@0: };
michael@0: 
michael@0: #  endif
michael@0: 
michael@0: struct _Node_alloc_obj {
michael@0:   _Node_alloc_obj * _M_next;
michael@0: };
michael@0: #endif
michael@0: 
michael@0: class __node_alloc_impl {
michael@0:   static inline size_t _STLP_CALL _S_round_up(size_t __bytes)
michael@0:   { return (((__bytes) + (size_t)_ALIGN-1) & ~((size_t)_ALIGN - 1)); }
michael@0: 
michael@0: #if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0:   typedef _STLP_atomic_freelist::item   _Obj;
michael@0:   typedef _STLP_atomic_freelist         _Freelist;
michael@0:   typedef _STLP_atomic_freelist         _ChunkList;
michael@0: 
michael@0:   // Header of blocks of memory that have been allocated as part of
michael@0:   // a larger chunk but have not yet been chopped up into nodes.
michael@0:   struct _FreeBlockHeader : public _STLP_atomic_freelist::item {
michael@0:     char* _M_end;     // pointer to end of free memory
michael@0:   };
michael@0: #else
michael@0:   typedef _Node_alloc_obj       _Obj;
michael@0:   typedef _Obj* _STLP_VOLATILE  _Freelist;
michael@0:   typedef _Obj*                 _ChunkList;
michael@0: #endif
michael@0: 
michael@0: private:
michael@0:   // Returns an object of size __n, and optionally adds to size __n free list.
michael@0:   static _Obj* _S_refill(size_t __n);
michael@0:   // Allocates a chunk for nobjs of size __p_size.  nobjs may be reduced
michael@0:   // if it is inconvenient to allocate the requested number.
michael@0:   static char* _S_chunk_alloc(size_t __p_size, int& __nobjs);
michael@0:   // Chunk allocation state.
michael@0:   static _Freelist _S_free_list[_STLP_NFREELISTS];
michael@0:   // Amount of total allocated memory
michael@0: #if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0:   static _STLP_VOLATILE __add_atomic_t _S_heap_size;
michael@0: #else
michael@0:   static size_t _S_heap_size;
michael@0: #endif
michael@0: 
michael@0: #if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0:   // List of blocks of free memory
michael@0:   static _STLP_atomic_freelist  _S_free_mem_blocks;
michael@0: #else
michael@0:   // Start of the current free memory buffer
michael@0:   static char* _S_start_free;
michael@0:   // End of the current free memory buffer
michael@0:   static char* _S_end_free;
michael@0: #endif
michael@0: 
michael@0: #if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0: public:
michael@0:   // Methods to report alloc/dealloc calls to the counter system.
michael@0: #  if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0:   typedef _STLP_VOLATILE __stl_atomic_t _AllocCounter;
michael@0: #  else
michael@0:   typedef __stl_atomic_t _AllocCounter;
michael@0: #  endif
michael@0:   static _AllocCounter& _STLP_CALL _S_alloc_counter();
michael@0:   static void _S_alloc_call();
michael@0:   static void _S_dealloc_call();
michael@0: 
michael@0: private:
michael@0:   // Free all the allocated chuncks of memory
michael@0:   static void _S_chunk_dealloc();
michael@0:   // Beginning of the linked list of allocated chunks of memory
michael@0:   static _ChunkList _S_chunks;
michael@0: #endif /* _STLP_DO_CLEAN_NODE_ALLOC */
michael@0: 
michael@0: public:
michael@0:   /* __n must be > 0      */
michael@0:   static void* _M_allocate(size_t& __n);
michael@0:   /* __p may not be 0 */
michael@0:   static void _M_deallocate(void *__p, size_t __n);
michael@0: };
michael@0: 
michael@0: #if !defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0: void* __node_alloc_impl::_M_allocate(size_t& __n) {
michael@0:   __n = _S_round_up(__n);
michael@0:   _Obj * _STLP_VOLATILE * __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
michael@0:   _Obj *__r;
michael@0: 
michael@0:   // Acquire the lock here with a constructor call.
michael@0:   // This ensures that it is released in exit or during stack
michael@0:   // unwinding.
michael@0:   _Node_Alloc_Lock __lock_instance;
michael@0: 
michael@0:   if ( (__r  = *__my_free_list) != 0 ) {
michael@0:     *__my_free_list = __r->_M_next;
michael@0:   } else {
michael@0:     __r = _S_refill(__n);
michael@0:   }
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0:   _S_alloc_call();
michael@0: #  endif
michael@0:   // lock is released here
michael@0:   return __r;
michael@0: }
michael@0: 
michael@0: void __node_alloc_impl::_M_deallocate(void *__p, size_t __n) {
michael@0:   _Obj * _STLP_VOLATILE * __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
michael@0:   _Obj * __pobj = __STATIC_CAST(_Obj*, __p);
michael@0: 
michael@0:   // acquire lock
michael@0:   _Node_Alloc_Lock __lock_instance;
michael@0:   __pobj->_M_next = *__my_free_list;
michael@0:   *__my_free_list = __pobj;
michael@0: 
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0:   _S_dealloc_call();
michael@0: #  endif
michael@0:   // lock is released here
michael@0: }
michael@0: 
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0: #    define _STLP_OFFSET sizeof(_Obj)
michael@0: #  else
michael@0: #    define _STLP_OFFSET 0
michael@0: #  endif
michael@0: 
michael@0: /* We allocate memory in large chunks in order to avoid fragmenting     */
michael@0: /* the malloc heap too much.                                            */
michael@0: /* We assume that size is properly aligned.                             */
michael@0: /* We hold the allocation lock.                                         */
michael@0: char* __node_alloc_impl::_S_chunk_alloc(size_t _p_size, int& __nobjs) {
michael@0:   char* __result;
michael@0:   size_t __total_bytes = _p_size * __nobjs;
michael@0:   size_t __bytes_left = _S_end_free - _S_start_free;
michael@0: 
michael@0:   if (__bytes_left > 0) {
michael@0:     if (__bytes_left >= __total_bytes) {
michael@0:       __result = _S_start_free;
michael@0:       _S_start_free += __total_bytes;
michael@0:       return __result;
michael@0:     }
michael@0: 
michael@0:     if (__bytes_left >= _p_size) {
michael@0:       __nobjs = (int)(__bytes_left / _p_size);
michael@0:       __total_bytes = _p_size * __nobjs;
michael@0:       __result = _S_start_free;
michael@0:       _S_start_free += __total_bytes;
michael@0:       return __result;
michael@0:     }
michael@0: 
michael@0:     // Try to make use of the left-over piece.
michael@0:     _Obj* _STLP_VOLATILE* __my_free_list = _S_free_list + _S_FREELIST_INDEX(__bytes_left);
michael@0:     __REINTERPRET_CAST(_Obj*, _S_start_free)->_M_next = *__my_free_list;
michael@0:     *__my_free_list = __REINTERPRET_CAST(_Obj*, _S_start_free);
michael@0:     _S_start_free = _S_end_free = 0;
michael@0:   }
michael@0: 
michael@0:   size_t __bytes_to_get = 2 * __total_bytes + _S_round_up(_S_heap_size) + _STLP_OFFSET;
michael@0: 
michael@0:   _STLP_TRY {
michael@0:     _S_start_free = __stlp_new_chunk(__bytes_to_get);
michael@0:   }
michael@0: #if defined (_STLP_USE_EXCEPTIONS)
michael@0:   catch (const _STLP_STD::bad_alloc&) {
michael@0:     _Obj* _STLP_VOLATILE* __my_free_list;
michael@0:     _Obj* __p;
michael@0:     // Try to do with what we have.  That can't hurt.
michael@0:     // We do not try smaller requests, since that tends
michael@0:     // to result in disaster on multi-process machines.
michael@0:     for (size_t __i = _p_size; __i <= (size_t)_MAX_BYTES; __i += (size_t)_ALIGN) {
michael@0:       __my_free_list = _S_free_list + _S_FREELIST_INDEX(__i);
michael@0:       __p = *__my_free_list;
michael@0:       if (0 != __p) {
michael@0:         *__my_free_list = __p -> _M_next;
michael@0:         _S_start_free = __REINTERPRET_CAST(char*, __p);
michael@0:         _S_end_free = _S_start_free + __i;
michael@0:         return _S_chunk_alloc(_p_size, __nobjs);
michael@0:         // Any leftover piece will eventually make it to the
michael@0:         // right free list.
michael@0:       }
michael@0:     }
michael@0:     __bytes_to_get = __total_bytes + _STLP_OFFSET;
michael@0:     _S_start_free = __stlp_new_chunk(__bytes_to_get);
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   _S_heap_size += __bytes_to_get >> 4;
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0:   __REINTERPRET_CAST(_Obj*, _S_start_free)->_M_next = _S_chunks;
michael@0:   _S_chunks = __REINTERPRET_CAST(_Obj*, _S_start_free);
michael@0: #  endif
michael@0:   _S_end_free = _S_start_free + __bytes_to_get;
michael@0:   _S_start_free += _STLP_OFFSET;
michael@0:   return _S_chunk_alloc(_p_size, __nobjs);
michael@0: }
michael@0: 
michael@0: /* Returns an object of size __n, and optionally adds to size __n free list.*/
michael@0: /* We assume that __n is properly aligned.                                  */
michael@0: /* We hold the allocation lock.                                             */
michael@0: _Node_alloc_obj* __node_alloc_impl::_S_refill(size_t __n) {
michael@0:   int __nobjs = 20;
michael@0:   char* __chunk = _S_chunk_alloc(__n, __nobjs);
michael@0: 
michael@0:   if (1 == __nobjs) return __REINTERPRET_CAST(_Obj*, __chunk);
michael@0: 
michael@0:   _Obj* _STLP_VOLATILE* __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
michael@0:   _Obj* __result;
michael@0:   _Obj* __current_obj;
michael@0:   _Obj* __next_obj;
michael@0: 
michael@0:   /* Build free list in chunk */
michael@0:   __result = __REINTERPRET_CAST(_Obj*, __chunk);
michael@0:   *__my_free_list = __next_obj = __REINTERPRET_CAST(_Obj*, __chunk + __n);
michael@0:   for (--__nobjs; --__nobjs; ) {
michael@0:     __current_obj = __next_obj;
michael@0:     __next_obj = __REINTERPRET_CAST(_Obj*, __REINTERPRET_CAST(char*, __next_obj) + __n);
michael@0:     __current_obj->_M_next = __next_obj;
michael@0:   }
michael@0:   __next_obj->_M_next = 0;
michael@0:   return __result;
michael@0: }
michael@0: 
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0: void __node_alloc_impl::_S_alloc_call()
michael@0: { ++_S_alloc_counter(); }
michael@0: 
michael@0: void __node_alloc_impl::_S_dealloc_call() {
michael@0:   __stl_atomic_t &counter = _S_alloc_counter();
michael@0:   if (--counter == 0)
michael@0:   { _S_chunk_dealloc(); }
michael@0: }
michael@0: 
michael@0: /* We deallocate all the memory chunks      */
michael@0: void __node_alloc_impl::_S_chunk_dealloc() {
michael@0:   _Obj *__pcur = _S_chunks, *__pnext;
michael@0:   while (__pcur != 0) {
michael@0:     __pnext = __pcur->_M_next;
michael@0:     __stlp_delete_chunck(__pcur);
michael@0:     __pcur = __pnext;
michael@0:   }
michael@0:   _S_chunks = 0;
michael@0:   _S_start_free = _S_end_free = 0;
michael@0:   _S_heap_size = 0;
michael@0:   memset(__REINTERPRET_CAST(char*, __CONST_CAST(_Obj**, &_S_free_list[0])), 0, _STLP_NFREELISTS * sizeof(_Obj*));
michael@0: }
michael@0: #  endif
michael@0: 
michael@0: #else
michael@0: 
michael@0: void* __node_alloc_impl::_M_allocate(size_t& __n) {
michael@0:   __n = _S_round_up(__n);
michael@0:   _Obj* __r = _S_free_list[_S_FREELIST_INDEX(__n)].pop();
michael@0:   if (__r  == 0)
michael@0:   { __r = _S_refill(__n); }
michael@0: 
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0:   _S_alloc_call();
michael@0: #  endif
michael@0:   return __r;
michael@0: }
michael@0: 
michael@0: void __node_alloc_impl::_M_deallocate(void *__p, size_t __n) {
michael@0:   _S_free_list[_S_FREELIST_INDEX(__n)].push(__STATIC_CAST(_Obj*, __p));
michael@0: 
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0:   _S_dealloc_call();
michael@0: #  endif
michael@0: }
michael@0: 
michael@0: /* Returns an object of size __n, and optionally adds additional ones to    */
michael@0: /* freelist of objects of size __n.                                         */
michael@0: /* We assume that __n is properly aligned.                                  */
michael@0: __node_alloc_impl::_Obj* __node_alloc_impl::_S_refill(size_t __n) {
michael@0:   int __nobjs = 20;
michael@0:   char* __chunk = _S_chunk_alloc(__n, __nobjs);
michael@0: 
michael@0:   if (__nobjs <= 1)
michael@0:     return __REINTERPRET_CAST(_Obj*, __chunk);
michael@0: 
michael@0:   // Push all new nodes (minus first one) onto freelist
michael@0:   _Obj* __result   = __REINTERPRET_CAST(_Obj*, __chunk);
michael@0:   _Obj* __cur_item = __result;
michael@0:   _Freelist* __my_freelist = _S_free_list + _S_FREELIST_INDEX(__n);
michael@0:   for (--__nobjs; __nobjs != 0; --__nobjs) {
michael@0:     __cur_item  = __REINTERPRET_CAST(_Obj*, __REINTERPRET_CAST(char*, __cur_item) + __n);
michael@0:     __my_freelist->push(__cur_item);
michael@0:   }
michael@0:   return __result;
michael@0: }
michael@0: 
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0: #    define _STLP_OFFSET _ALIGN
michael@0: #  else
michael@0: #    define _STLP_OFFSET 0
michael@0: #  endif
michael@0: 
michael@0: /* We allocate memory in large chunks in order to avoid fragmenting     */
michael@0: /* the malloc heap too much.                                            */
michael@0: /* We assume that size is properly aligned.                             */
michael@0: char* __node_alloc_impl::_S_chunk_alloc(size_t _p_size, int& __nobjs) {
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0:   //We are going to add a small memory block to keep all the allocated blocks
michael@0:   //address, we need to do so respecting the memory alignment. The following
michael@0:   //static assert checks that the reserved block is big enough to store a pointer.
michael@0:   _STLP_STATIC_ASSERT(sizeof(_Obj) <= _ALIGN)
michael@0: #  endif
michael@0:   char*  __result       = 0;
michael@0:   __add_atomic_t __total_bytes  = __STATIC_CAST(__add_atomic_t, _p_size) * __nobjs;
michael@0: 
michael@0:   _FreeBlockHeader* __block = __STATIC_CAST(_FreeBlockHeader*, _S_free_mem_blocks.pop());
michael@0:   if (__block != 0) {
michael@0:     // We checked a block out and can now mess with it with impugnity.
michael@0:     // We'll put the remainder back into the list if we're done with it below.
michael@0:     char*  __buf_start  = __REINTERPRET_CAST(char*, __block);
michael@0:     __add_atomic_t __bytes_left = __block->_M_end - __buf_start;
michael@0: 
michael@0:     if ((__bytes_left < __total_bytes) && (__bytes_left >= __STATIC_CAST(__add_atomic_t, _p_size))) {
michael@0:       // There's enough left for at least one object, but not as much as we wanted
michael@0:       __result      = __buf_start;
michael@0:       __nobjs       = (int)(__bytes_left/_p_size);
michael@0:       __total_bytes = __STATIC_CAST(__add_atomic_t, _p_size) * __nobjs;
michael@0:       __bytes_left -= __total_bytes;
michael@0:       __buf_start  += __total_bytes;
michael@0:     }
michael@0:     else if (__bytes_left >= __total_bytes) {
michael@0:       // The block has enough left to satisfy all that was asked for
michael@0:       __result      = __buf_start;
michael@0:       __bytes_left -= __total_bytes;
michael@0:       __buf_start  += __total_bytes;
michael@0:     }
michael@0: 
michael@0:     if (__bytes_left != 0) {
michael@0:       // There is still some memory left over in block after we satisfied our request.
michael@0:       if ((__result != 0) && (__bytes_left >= (__add_atomic_t)sizeof(_FreeBlockHeader))) {
michael@0:         // We were able to allocate at least one object and there is still enough
michael@0:         // left to put remainder back into list.
michael@0:         _FreeBlockHeader* __newblock = __REINTERPRET_CAST(_FreeBlockHeader*, __buf_start);
michael@0:         __newblock->_M_end  = __block->_M_end;
michael@0:         _S_free_mem_blocks.push(__newblock);
michael@0:       }
michael@0:       else {
michael@0:         // We were not able to allocate enough for at least one object.
michael@0:         // Shove into freelist of nearest (rounded-down!) size.
michael@0:         size_t __rounded_down = _S_round_up(__bytes_left + 1) - (size_t)_ALIGN;
michael@0:         if (__rounded_down > 0)
michael@0:           _S_free_list[_S_FREELIST_INDEX(__rounded_down)].push((_Obj*)__buf_start);
michael@0:       }
michael@0:     }
michael@0:     if (__result != 0)
michael@0:       return __result;
michael@0:   }
michael@0: 
michael@0:   // We couldn't satisfy it from the list of free blocks, get new memory.
michael@0:   __add_atomic_t __bytes_to_get = 2 * __total_bytes +
michael@0:                                   __STATIC_CAST(__add_atomic_t,
michael@0:                                                 _S_round_up(__STATIC_CAST(__uadd_atomic_t, _STLP_ATOMIC_ADD(&_S_heap_size, 0)))) +
michael@0:                                   _STLP_OFFSET;
michael@0:   _STLP_TRY {
michael@0:     __result = __stlp_new_chunk(__bytes_to_get);
michael@0:   }
michael@0: #if defined (_STLP_USE_EXCEPTIONS)
michael@0:   catch (const bad_alloc&) {
michael@0:     // Allocation failed; try to canibalize from freelist of a larger object size.
michael@0:     for (size_t __i = _p_size; __i <= (size_t)_MAX_BYTES; __i += (size_t)_ALIGN) {
michael@0:       _Obj* __p  = _S_free_list[_S_FREELIST_INDEX(__i)].pop();
michael@0:       if (0 != __p) {
michael@0:         if (__i < sizeof(_FreeBlockHeader)) {
michael@0:           // Not enough to put into list of free blocks, divvy it up here.
michael@0:           // Use as much as possible for this request and shove remainder into freelist.
michael@0:           __nobjs = (int)(__i/_p_size);
michael@0:           __total_bytes = __nobjs * __STATIC_CAST(__add_atomic_t, _p_size);
michael@0:           size_t __bytes_left = __i - __total_bytes;
michael@0:           size_t __rounded_down = _S_round_up(__bytes_left+1) - (size_t)_ALIGN;
michael@0:           if (__rounded_down > 0) {
michael@0:             _S_free_list[_S_FREELIST_INDEX(__rounded_down)].push(__REINTERPRET_CAST(_Obj*, __REINTERPRET_CAST(char*, __p) + __total_bytes));
michael@0:           }
michael@0:           return __REINTERPRET_CAST(char*, __p);
michael@0:         }
michael@0:         else {
michael@0:           // Add node to list of available blocks and recursively allocate from it.
michael@0:           _FreeBlockHeader* __newblock = (_FreeBlockHeader*)__p;
michael@0:           __newblock->_M_end  = __REINTERPRET_CAST(char*, __p) + __i;
michael@0:           _S_free_mem_blocks.push(__newblock);
michael@0:           return _S_chunk_alloc(_p_size, __nobjs);
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // We were not able to find something in a freelist, try to allocate a smaller amount.
michael@0:     __bytes_to_get  = __total_bytes + _STLP_OFFSET;
michael@0:     __result = __stlp_new_chunk(__bytes_to_get);
michael@0: 
michael@0:     // This should either throw an exception or remedy the situation.
michael@0:     // Thus we assume it succeeded.
michael@0:   }
michael@0: #endif
michael@0:   // Alignment check
michael@0:   _STLP_VERBOSE_ASSERT(((__REINTERPRET_CAST(size_t, __result) & __STATIC_CAST(size_t, _ALIGN - 1)) == 0),
michael@0:                        _StlMsg_DBA_DELETED_TWICE)
michael@0:   _STLP_ATOMIC_ADD(&_S_heap_size, __bytes_to_get >> 4);
michael@0: 
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0:   // We have to track the allocated memory chunks for release on exit.
michael@0:   _S_chunks.push(__REINTERPRET_CAST(_Obj*, __result));
michael@0:   __result       += _ALIGN;
michael@0:   __bytes_to_get -= _ALIGN;
michael@0: #  endif
michael@0: 
michael@0:   if (__bytes_to_get > __total_bytes) {
michael@0:     // Push excess memory allocated in this chunk into list of free memory blocks
michael@0:     _FreeBlockHeader* __freeblock = __REINTERPRET_CAST(_FreeBlockHeader*, __result + __total_bytes);
michael@0:     __freeblock->_M_end  = __result + __bytes_to_get;
michael@0:     _S_free_mem_blocks.push(__freeblock);
michael@0:   }
michael@0:   return __result;
michael@0: }
michael@0: 
michael@0: #  if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0: void __node_alloc_impl::_S_alloc_call()
michael@0: { _STLP_ATOMIC_INCREMENT(&_S_alloc_counter()); }
michael@0: 
michael@0: void __node_alloc_impl::_S_dealloc_call() {
michael@0:   _STLP_VOLATILE __stl_atomic_t *pcounter = &_S_alloc_counter();
michael@0:   if (_STLP_ATOMIC_DECREMENT(pcounter) == 0)
michael@0:     _S_chunk_dealloc();
michael@0: }
michael@0: 
michael@0: /* We deallocate all the memory chunks      */
michael@0: void __node_alloc_impl::_S_chunk_dealloc() {
michael@0:   // Note: The _Node_alloc_helper class ensures that this function
michael@0:   // will only be called when the (shared) library is unloaded or the
michael@0:   // process is shutdown.  It's thus not possible that another thread
michael@0:   // is currently trying to allocate a node (we're not thread-safe here).
michael@0:   //
michael@0: 
michael@0:   // Clear the free blocks and all freelistst.  This makes sure that if
michael@0:   // for some reason more memory is allocated again during shutdown
michael@0:   // (it'd also be really nasty to leave references to deallocated memory).
michael@0:   _S_free_mem_blocks.clear();
michael@0:   _S_heap_size      = 0;
michael@0: 
michael@0:   for (size_t __i = 0; __i < _STLP_NFREELISTS; ++__i) {
michael@0:     _S_free_list[__i].clear();
michael@0:   }
michael@0: 
michael@0:   // Detach list of chunks and free them all
michael@0:   _Obj* __chunk = _S_chunks.clear();
michael@0:   while (__chunk != 0) {
michael@0:     _Obj* __next = __chunk->_M_next;
michael@0:     __stlp_delete_chunck(__chunk);
michael@0:     __chunk  = __next;
michael@0:   }
michael@0: }
michael@0: #  endif
michael@0: 
michael@0: #endif
michael@0: 
michael@0: #if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0: struct __node_alloc_cleaner {
michael@0:   ~__node_alloc_cleaner()
michael@0:   { __node_alloc_impl::_S_dealloc_call(); }
michael@0: };
michael@0: 
michael@0: #  if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0: _STLP_VOLATILE __stl_atomic_t& _STLP_CALL
michael@0: #  else
michael@0: __stl_atomic_t& _STLP_CALL
michael@0: #  endif
michael@0: __node_alloc_impl::_S_alloc_counter() {
michael@0:   static _AllocCounter _S_counter = 1;
michael@0:   static __node_alloc_cleaner _S_node_alloc_cleaner;
michael@0:   return _S_counter;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: #if !defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0: _Node_alloc_obj * _STLP_VOLATILE
michael@0: __node_alloc_impl::_S_free_list[_STLP_NFREELISTS]
michael@0: = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
michael@0: // The 16 zeros are necessary to make version 4.1 of the SunPro
michael@0: // compiler happy.  Otherwise it appears to allocate too little
michael@0: // space for the array.
michael@0: #else
michael@0: _STLP_atomic_freelist __node_alloc_impl::_S_free_list[_STLP_NFREELISTS];
michael@0: _STLP_atomic_freelist __node_alloc_impl::_S_free_mem_blocks;
michael@0: #endif
michael@0: 
michael@0: #if !defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0: char *__node_alloc_impl::_S_start_free = 0;
michael@0: char *__node_alloc_impl::_S_end_free = 0;
michael@0: #endif
michael@0: 
michael@0: #if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0: _STLP_VOLATILE __add_atomic_t
michael@0: #else
michael@0: size_t
michael@0: #endif
michael@0: __node_alloc_impl::_S_heap_size = 0;
michael@0: 
michael@0: #if defined (_STLP_DO_CLEAN_NODE_ALLOC)
michael@0: #  if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
michael@0: _STLP_atomic_freelist __node_alloc_impl::_S_chunks;
michael@0: #  else
michael@0: _Node_alloc_obj* __node_alloc_impl::_S_chunks  = 0;
michael@0: #  endif
michael@0: #endif
michael@0: 
michael@0: void * _STLP_CALL __node_alloc::_M_allocate(size_t& __n)
michael@0: { return __node_alloc_impl::_M_allocate(__n); }
michael@0: 
michael@0: void _STLP_CALL __node_alloc::_M_deallocate(void *__p, size_t __n)
michael@0: { __node_alloc_impl::_M_deallocate(__p, __n); }
michael@0: 
michael@0: #if defined (_STLP_PTHREADS) && !defined (_STLP_NO_THREADS)
michael@0: 
michael@0: #  define _STLP_DATA_ALIGNMENT 8
michael@0: 
michael@0: _STLP_MOVE_TO_PRIV_NAMESPACE
michael@0: 
michael@0: // *******************************************************
michael@0: // __perthread_alloc implementation
michael@0: union _Pthread_alloc_obj {
michael@0:   union _Pthread_alloc_obj * __free_list_link;
michael@0:   char __client_data[_STLP_DATA_ALIGNMENT];    /* The client sees this.    */
michael@0: };
michael@0: 
michael@0: // Pthread allocators don't appear to the client to have meaningful
michael@0: // instances.  We do in fact need to associate some state with each
michael@0: // thread.  That state is represented by _Pthread_alloc_per_thread_state.
michael@0: 
michael@0: struct _Pthread_alloc_per_thread_state {
michael@0:   typedef _Pthread_alloc_obj __obj;
michael@0:   enum { _S_NFREELISTS = _MAX_BYTES / _STLP_DATA_ALIGNMENT };
michael@0: 
michael@0:   // Free list link for list of available per thread structures.
michael@0:   // When one of these becomes available for reuse due to thread
michael@0:   // termination, any objects in its free list remain associated
michael@0:   // with it.  The whole structure may then be used by a newly
michael@0:   // created thread.
michael@0:   _Pthread_alloc_per_thread_state() : __next(0)
michael@0:   { memset((void *)__CONST_CAST(_Pthread_alloc_obj**, __free_list), 0, (size_t)_S_NFREELISTS * sizeof(__obj *)); }
michael@0:   // Returns an object of size __n, and possibly adds to size n free list.
michael@0:   void *_M_refill(size_t __n);
michael@0: 
michael@0:   _Pthread_alloc_obj* volatile __free_list[_S_NFREELISTS];
michael@0:   _Pthread_alloc_per_thread_state *__next;
michael@0:   // this data member is only to be used by per_thread_allocator, which returns memory to the originating thread.
michael@0:   _STLP_mutex _M_lock;
michael@0: };
michael@0: 
michael@0: // Pthread-specific allocator.
michael@0: class _Pthread_alloc_impl {
michael@0: public: // but only for internal use:
michael@0:   typedef _Pthread_alloc_per_thread_state __state_type;
michael@0:   typedef char value_type;
michael@0: 
michael@0:   // Allocates a chunk for nobjs of size size.  nobjs may be reduced
michael@0:   // if it is inconvenient to allocate the requested number.
michael@0:   static char *_S_chunk_alloc(size_t __size, size_t &__nobjs, __state_type*);
michael@0: 
michael@0:   enum {_S_ALIGN = _STLP_DATA_ALIGNMENT};
michael@0: 
michael@0:   static size_t _S_round_up(size_t __bytes)
michael@0:   { return (((__bytes) + (int)_S_ALIGN - 1) & ~((int)_S_ALIGN - 1)); }
michael@0:   static size_t _S_freelist_index(size_t __bytes)
michael@0:   { return (((__bytes) + (int)_S_ALIGN - 1) / (int)_S_ALIGN - 1); }
michael@0: 
michael@0: private:
michael@0:   // Chunk allocation state. And other shared state.
michael@0:   // Protected by _S_chunk_allocator_lock.
michael@0:   static _STLP_STATIC_MUTEX _S_chunk_allocator_lock;
michael@0:   static char *_S_start_free;
michael@0:   static char *_S_end_free;
michael@0:   static size_t _S_heap_size;
michael@0:   static __state_type *_S_free_per_thread_states;
michael@0:   static pthread_key_t _S_key;
michael@0:   static bool _S_key_initialized;
michael@0:   // Pthread key under which per thread state is stored.
michael@0:   // Allocator instances that are currently unclaimed by any thread.
michael@0:   static void _S_destructor(void *instance);
michael@0:   // Function to be called on thread exit to reclaim per thread
michael@0:   // state.
michael@0:   static __state_type *_S_new_per_thread_state();
michael@0: public:
michael@0:   // Return a recycled or new per thread state.
michael@0:   static __state_type *_S_get_per_thread_state();
michael@0: private:
michael@0:         // ensure that the current thread has an associated
michael@0:         // per thread state.
michael@0:   class _M_lock;
michael@0:   friend class _M_lock;
michael@0:   class _M_lock {
michael@0:   public:
michael@0:     _M_lock () { _S_chunk_allocator_lock._M_acquire_lock(); }
michael@0:     ~_M_lock () { _S_chunk_allocator_lock._M_release_lock(); }
michael@0:   };
michael@0: 
michael@0: public:
michael@0: 
michael@0:   /* n must be > 0      */
michael@0:   static void * allocate(size_t& __n);
michael@0: 
michael@0:   /* p may not be 0 */
michael@0:   static void deallocate(void *__p, size_t __n);
michael@0: 
michael@0:   // boris : versions for per_thread_allocator
michael@0:   /* n must be > 0      */
michael@0:   static void * allocate(size_t& __n, __state_type* __a);
michael@0: 
michael@0:   /* p may not be 0 */
michael@0:   static void deallocate(void *__p, size_t __n, __state_type* __a);
michael@0: 
michael@0:   static void * reallocate(void *__p, size_t __old_sz, size_t& __new_sz);
michael@0: };
michael@0: 
michael@0: /* Returns an object of size n, and optionally adds to size n free list.*/
michael@0: /* We assume that n is properly aligned.                                */
michael@0: /* We hold the allocation lock.                                         */
michael@0: void *_Pthread_alloc_per_thread_state::_M_refill(size_t __n) {
michael@0:   typedef _Pthread_alloc_obj __obj;
michael@0:   size_t __nobjs = 128;
michael@0:   char * __chunk = _Pthread_alloc_impl::_S_chunk_alloc(__n, __nobjs, this);
michael@0:   __obj * volatile * __my_free_list;
michael@0:   __obj * __result;
michael@0:   __obj * __current_obj, * __next_obj;
michael@0:   size_t __i;
michael@0: 
michael@0:   if (1 == __nobjs)  {
michael@0:     return __chunk;
michael@0:   }
michael@0: 
michael@0:   __my_free_list = __free_list + _Pthread_alloc_impl::_S_freelist_index(__n);
michael@0: 
michael@0:   /* Build free list in chunk */
michael@0:   __result = (__obj *)__chunk;
michael@0:   *__my_free_list = __next_obj = (__obj *)(__chunk + __n);
michael@0:   for (__i = 1; ; ++__i) {
michael@0:     __current_obj = __next_obj;
michael@0:     __next_obj = (__obj *)((char *)__next_obj + __n);
michael@0:     if (__nobjs - 1 == __i) {
michael@0:       __current_obj -> __free_list_link = 0;
michael@0:       break;
michael@0:     } else {
michael@0:       __current_obj -> __free_list_link = __next_obj;
michael@0:     }
michael@0:   }
michael@0:   return __result;
michael@0: }
michael@0: 
michael@0: void _Pthread_alloc_impl::_S_destructor(void *__instance) {
michael@0:   _M_lock __lock_instance;  // Need to acquire lock here.
michael@0:   _Pthread_alloc_per_thread_state* __s = (_Pthread_alloc_per_thread_state*)__instance;
michael@0:   __s -> __next = _S_free_per_thread_states;
michael@0:   _S_free_per_thread_states = __s;
michael@0: }
michael@0: 
michael@0: _Pthread_alloc_per_thread_state* _Pthread_alloc_impl::_S_new_per_thread_state() {
michael@0:   /* lock already held here.  */
michael@0:   if (0 != _S_free_per_thread_states) {
michael@0:     _Pthread_alloc_per_thread_state *__result = _S_free_per_thread_states;
michael@0:     _S_free_per_thread_states = _S_free_per_thread_states -> __next;
michael@0:     return __result;
michael@0:   }
michael@0:   else {
michael@0:     return new _Pthread_alloc_per_thread_state;
michael@0:   }
michael@0: }
michael@0: 
michael@0: _Pthread_alloc_per_thread_state* _Pthread_alloc_impl::_S_get_per_thread_state() {
michael@0:   int __ret_code;
michael@0:   __state_type* __result;
michael@0: 
michael@0:   if (_S_key_initialized && (__result = (__state_type*) pthread_getspecific(_S_key)))
michael@0:     return __result;
michael@0: 
michael@0:   /*REFERENCED*/
michael@0:   _M_lock __lock_instance;  // Need to acquire lock here.
michael@0:   if (!_S_key_initialized) {
michael@0:     if (pthread_key_create(&_S_key, _S_destructor)) {
michael@0:       _STLP_THROW_BAD_ALLOC;  // failed
michael@0:     }
michael@0:     _S_key_initialized = true;
michael@0:   }
michael@0: 
michael@0:   __result = _S_new_per_thread_state();
michael@0:   __ret_code = pthread_setspecific(_S_key, __result);
michael@0:   if (__ret_code) {
michael@0:     if (__ret_code == ENOMEM) {
michael@0:       _STLP_THROW_BAD_ALLOC;
michael@0:     } else {
michael@0:   // EINVAL
michael@0:       _STLP_ABORT();
michael@0:     }
michael@0:   }
michael@0:   return __result;
michael@0: }
michael@0: 
michael@0: /* We allocate memory in large chunks in order to avoid fragmenting     */
michael@0: /* the malloc heap too much.                                            */
michael@0: /* We assume that size is properly aligned.                             */
michael@0: char *_Pthread_alloc_impl::_S_chunk_alloc(size_t __p_size, size_t &__nobjs, _Pthread_alloc_per_thread_state *__a) {
michael@0:   typedef _Pthread_alloc_obj __obj;
michael@0:   {
michael@0:     char * __result;
michael@0:     size_t __total_bytes;
michael@0:     size_t __bytes_left;
michael@0:     /*REFERENCED*/
michael@0:     _M_lock __lock_instance;         // Acquire lock for this routine
michael@0: 
michael@0:     __total_bytes = __p_size * __nobjs;
michael@0:     __bytes_left = _S_end_free - _S_start_free;
michael@0:     if (__bytes_left >= __total_bytes) {
michael@0:       __result = _S_start_free;
michael@0:       _S_start_free += __total_bytes;
michael@0:       return __result;
michael@0:     } else if (__bytes_left >= __p_size) {
michael@0:       __nobjs = __bytes_left/__p_size;
michael@0:       __total_bytes = __p_size * __nobjs;
michael@0:       __result = _S_start_free;
michael@0:       _S_start_free += __total_bytes;
michael@0:       return __result;
michael@0:     } else {
michael@0:       size_t __bytes_to_get = 2 * __total_bytes + _S_round_up(_S_heap_size);
michael@0:       // Try to make use of the left-over piece.
michael@0:       if (__bytes_left > 0) {
michael@0:         __obj * volatile * __my_free_list = __a->__free_list + _S_freelist_index(__bytes_left);
michael@0:         ((__obj *)_S_start_free) -> __free_list_link = *__my_free_list;
michael@0:         *__my_free_list = (__obj *)_S_start_free;
michael@0:       }
michael@0: #  ifdef _SGI_SOURCE
michael@0:       // Try to get memory that's aligned on something like a
michael@0:       // cache line boundary, so as to avoid parceling out
michael@0:       // parts of the same line to different threads and thus
michael@0:       // possibly different processors.
michael@0:       {
michael@0:         const int __cache_line_size = 128;  // probable upper bound
michael@0:         __bytes_to_get &= ~(__cache_line_size-1);
michael@0:         _S_start_free = (char *)memalign(__cache_line_size, __bytes_to_get);
michael@0:         if (0 == _S_start_free) {
michael@0:           _S_start_free = (char *)__malloc_alloc::allocate(__bytes_to_get);
michael@0:         }
michael@0:       }
michael@0: #  else  /* !SGI_SOURCE */
michael@0:       _S_start_free = (char *)__malloc_alloc::allocate(__bytes_to_get);
michael@0: #  endif
michael@0:       _S_heap_size += __bytes_to_get >> 4;
michael@0:       _S_end_free = _S_start_free + __bytes_to_get;
michael@0:     }
michael@0:   }
michael@0:   // lock is released here
michael@0:   return _S_chunk_alloc(__p_size, __nobjs, __a);
michael@0: }
michael@0: 
michael@0: 
michael@0: /* n must be > 0      */
michael@0: void *_Pthread_alloc_impl::allocate(size_t& __n) {
michael@0:   typedef _Pthread_alloc_obj __obj;
michael@0:   __obj * volatile * __my_free_list;
michael@0:   __obj * __result;
michael@0:   __state_type* __a;
michael@0: 
michael@0:   if (__n > _MAX_BYTES) {
michael@0:     return __malloc_alloc::allocate(__n);
michael@0:   }
michael@0: 
michael@0:   __n = _S_round_up(__n);
michael@0:   __a = _S_get_per_thread_state();
michael@0: 
michael@0:   __my_free_list = __a->__free_list + _S_freelist_index(__n);
michael@0:   __result = *__my_free_list;
michael@0:   if (__result == 0) {
michael@0:     void *__r = __a->_M_refill(__n);
michael@0:     return __r;
michael@0:   }
michael@0:   *__my_free_list = __result->__free_list_link;
michael@0:   return __result;
michael@0: };
michael@0: 
michael@0: /* p may not be 0 */
michael@0: void _Pthread_alloc_impl::deallocate(void *__p, size_t __n) {
michael@0:   typedef _Pthread_alloc_obj __obj;
michael@0:   __obj *__q = (__obj *)__p;
michael@0:   __obj * volatile * __my_free_list;
michael@0:   __state_type* __a;
michael@0: 
michael@0:   if (__n > _MAX_BYTES) {
michael@0:       __malloc_alloc::deallocate(__p, __n);
michael@0:       return;
michael@0:   }
michael@0: 
michael@0:   __a = _S_get_per_thread_state();
michael@0: 
michael@0:   __my_free_list = __a->__free_list + _S_freelist_index(__n);
michael@0:   __q -> __free_list_link = *__my_free_list;
michael@0:   *__my_free_list = __q;
michael@0: }
michael@0: 
michael@0: // boris : versions for per_thread_allocator
michael@0: /* n must be > 0      */
michael@0: void *_Pthread_alloc_impl::allocate(size_t& __n, __state_type* __a) {
michael@0:   typedef _Pthread_alloc_obj __obj;
michael@0:   __obj * volatile * __my_free_list;
michael@0:   __obj * __result;
michael@0: 
michael@0:   if (__n > _MAX_BYTES) {
michael@0:     return __malloc_alloc::allocate(__n);
michael@0:   }
michael@0:   __n = _S_round_up(__n);
michael@0: 
michael@0:   // boris : here, we have to lock per thread state, as we may be getting memory from
michael@0:   // different thread pool.
michael@0:   _STLP_auto_lock __lock(__a->_M_lock);
michael@0: 
michael@0:   __my_free_list = __a->__free_list + _S_freelist_index(__n);
michael@0:   __result = *__my_free_list;
michael@0:   if (__result == 0) {
michael@0:     void *__r = __a->_M_refill(__n);
michael@0:     return __r;
michael@0:   }
michael@0:   *__my_free_list = __result->__free_list_link;
michael@0:   return __result;
michael@0: };
michael@0: 
michael@0: /* p may not be 0 */
michael@0: void _Pthread_alloc_impl::deallocate(void *__p, size_t __n, __state_type* __a) {
michael@0:   typedef _Pthread_alloc_obj __obj;
michael@0:   __obj *__q = (__obj *)__p;
michael@0:   __obj * volatile * __my_free_list;
michael@0: 
michael@0:   if (__n > _MAX_BYTES) {
michael@0:     __malloc_alloc::deallocate(__p, __n);
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // boris : here, we have to lock per thread state, as we may be returning memory from
michael@0:   // different thread.
michael@0:   _STLP_auto_lock __lock(__a->_M_lock);
michael@0: 
michael@0:   __my_free_list = __a->__free_list + _S_freelist_index(__n);
michael@0:   __q -> __free_list_link = *__my_free_list;
michael@0:   *__my_free_list = __q;
michael@0: }
michael@0: 
michael@0: void *_Pthread_alloc_impl::reallocate(void *__p, size_t __old_sz, size_t& __new_sz) {
michael@0:   void * __result;
michael@0:   size_t __copy_sz;
michael@0: 
michael@0:   if (__old_sz > _MAX_BYTES && __new_sz > _MAX_BYTES) {
michael@0:     return realloc(__p, __new_sz);
michael@0:   }
michael@0: 
michael@0:   if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return __p;
michael@0:   __result = allocate(__new_sz);
michael@0:   __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
michael@0:   memcpy(__result, __p, __copy_sz);
michael@0:   deallocate(__p, __old_sz);
michael@0:   return __result;
michael@0: }
michael@0: 
michael@0: _Pthread_alloc_per_thread_state* _Pthread_alloc_impl::_S_free_per_thread_states = 0;
michael@0: pthread_key_t _Pthread_alloc_impl::_S_key = 0;
michael@0: _STLP_STATIC_MUTEX _Pthread_alloc_impl::_S_chunk_allocator_lock _STLP_MUTEX_INITIALIZER;
michael@0: bool _Pthread_alloc_impl::_S_key_initialized = false;
michael@0: char *_Pthread_alloc_impl::_S_start_free = 0;
michael@0: char *_Pthread_alloc_impl::_S_end_free = 0;
michael@0: size_t _Pthread_alloc_impl::_S_heap_size = 0;
michael@0: 
michael@0: void * _STLP_CALL _Pthread_alloc::allocate(size_t& __n)
michael@0: { return _Pthread_alloc_impl::allocate(__n); }
michael@0: void _STLP_CALL _Pthread_alloc::deallocate(void *__p, size_t __n)
michael@0: { _Pthread_alloc_impl::deallocate(__p, __n); }
michael@0: void * _STLP_CALL _Pthread_alloc::allocate(size_t& __n, __state_type* __a)
michael@0: { return _Pthread_alloc_impl::allocate(__n, __a); }
michael@0: void _STLP_CALL _Pthread_alloc::deallocate(void *__p, size_t __n, __state_type* __a)
michael@0: { _Pthread_alloc_impl::deallocate(__p, __n, __a); }
michael@0: void * _STLP_CALL _Pthread_alloc::reallocate(void *__p, size_t __old_sz, size_t& __new_sz)
michael@0: { return _Pthread_alloc_impl::reallocate(__p, __old_sz, __new_sz); }
michael@0: _Pthread_alloc_per_thread_state* _STLP_CALL _Pthread_alloc::_S_get_per_thread_state()
michael@0: { return _Pthread_alloc_impl::_S_get_per_thread_state(); }
michael@0: 
michael@0: _STLP_MOVE_TO_STD_NAMESPACE
michael@0: 
michael@0: #endif
michael@0: 
michael@0: _STLP_END_NAMESPACE
michael@0: 
michael@0: #undef _S_FREELIST_INDEX