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