/home/ntakagi/work/STLport-5.1.5/stlport/stl/_pthread_alloc.h Go to the documentation of this file. /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Copyright (c) 1996,1997 * Silicon Graphics Computer Systems, Inc. * * Copyright (c) 1997 * Moscow Center for SPARC Technology * * Copyright (c) 1999 * Boris Fomitchev * * This material is provided "as is", with absolutely no warranty expressed * or implied. Any use is at your own risk. * * Permission to use or copy this software for any purpose is hereby granted * without fee, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #ifndef _STLP_PTHREAD_ALLOC_H #define _STLP_PTHREAD_ALLOC_H /* * Pthread-specific node allocator. * This is similar to the default allocator, except that free-list * information is kept separately for each thread, avoiding locking. * This should be reasonably fast even in the presence of threads. * The down side is that storage may not be well-utilized. * It is not an error to allocate memory in thread A and deallocate * it in thread B. But this effectively transfers ownership of the memory, * so that it can only be reallocated by thread B. Thus this can effectively * result in a storage leak if it's done on a regular basis. * It can also result in frequent sharing of * cache lines among processors, with potentially serious performance * consequences. */ #if !defined (_STLP_PTHREADS) # error POSIX specific allocator implementation. Your system do not seems to \ have this interface so please comment the _STLP_USE_PERTHREAD_ALLOC macro \ or report to the STLport forum. #endif #if defined (_STLP_USE_NO_IOSTREAMS) # error You cannot use per thread allocator implementation without building \ STLport libraries. #endif #ifndef _STLP_INTERNAL_ALLOC_H # include <stl/_alloc.h> #endif _STLP_BEGIN_NAMESPACE _STLP_MOVE_TO_PRIV_NAMESPACE struct _Pthread_alloc_per_thread_state; // Pthread-specific allocator. class _STLP_CLASS_DECLSPEC _Pthread_alloc { public: // but only for internal use: typedef _Pthread_alloc_per_thread_state __state_type; typedef char value_type; public: // Return a recycled or new per thread state. static __state_type * _STLP_CALL _S_get_per_thread_state(); /* n must be > 0 */ static void * _STLP_CALL allocate(size_t& __n); /* p may not be 0 */ static void _STLP_CALL deallocate(void *__p, size_t __n); // boris : versions for per_thread_allocator /* n must be > 0 */ static void * _STLP_CALL allocate(size_t& __n, __state_type* __a); /* p may not be 0 */ static void _STLP_CALL deallocate(void *__p, size_t __n, __state_type* __a); static void * _STLP_CALL reallocate(void *__p, size_t __old_sz, size_t& __new_sz); }; _STLP_MOVE_TO_STD_NAMESPACE typedef _STLP_PRIV _Pthread_alloc __pthread_alloc; typedef __pthread_alloc pthread_alloc; template <class _Tp> class pthread_allocator : public __stlport_class<pthread_allocator<_Tp> > { typedef pthread_alloc _S_Alloc; // The underlying allocator. public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Tp* pointer; typedef const _Tp* const_pointer; typedef _Tp& reference; typedef const _Tp& const_reference; typedef _Tp value_type; #ifdef _STLP_MEMBER_TEMPLATE_CLASSES template <class _NewType> struct rebind { typedef pthread_allocator<_NewType> other; }; #endif pthread_allocator() _STLP_NOTHROW {} pthread_allocator(const pthread_allocator<_Tp>& a) _STLP_NOTHROW {} #if defined (_STLP_MEMBER_TEMPLATES) /* && defined (_STLP_FUNCTION_PARTIAL_ORDER) */ template <class _OtherType> pthread_allocator(const pthread_allocator<_OtherType>&) _STLP_NOTHROW {} #endif ~pthread_allocator() _STLP_NOTHROW {} pointer address(reference __x) const { return &__x; } const_pointer address(const_reference __x) const { return &__x; } // __n is permitted to be 0. The C++ standard says nothing about what // the return value is when __n == 0. _Tp* allocate(size_type __n, const void* = 0) { if (__n > max_size()) { __THROW_BAD_ALLOC; } if (__n != 0) { size_type __buf_size = __n * sizeof(value_type); _Tp* __ret = __REINTERPRET_CAST(value_type*, _S_Alloc::allocate(__buf_size)); #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC) if (__ret != 0) { memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size); } #endif return __ret; } else return 0; } void deallocate(pointer __p, size_type __n) { _STLP_ASSERT( (__p == 0) == (__n == 0) ) if (__p != 0) { #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC) memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type)); #endif _S_Alloc::deallocate(__p, __n * sizeof(value_type)); } } size_type max_size() const _STLP_NOTHROW { return size_t(-1) / sizeof(_Tp); } void construct(pointer __p, const _Tp& __val) { _STLP_PLACEMENT_NEW (__p) _Tp(__val); } void destroy(pointer _p) { _p->~_Tp(); } #if defined (_STLP_NO_EXTENSIONS) /* STLport extension giving rounded size of an allocated memory buffer * This method do not have to be part of a user defined allocator implementation * and won't even be called if such a function was granted. */ protected: #endif _Tp* allocate(size_type __n, size_type& __allocated_n) { if (__n > max_size()) { __THROW_BAD_ALLOC; } if (__n != 0) { size_type __buf_size = __n * sizeof(value_type); _Tp* __ret = __REINTERPRET_CAST(value_type*, _S_Alloc::allocate(__buf_size)); #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC) if (__ret != 0) { memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size); } #endif __allocated_n = __buf_size / sizeof(value_type); return __ret; } else return 0; } }; _STLP_TEMPLATE_NULL class _STLP_CLASS_DECLSPEC pthread_allocator<void> { public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef void* pointer; typedef const void* const_pointer; typedef void value_type; #ifdef _STLP_MEMBER_TEMPLATE_CLASSES template <class _NewType> struct rebind { typedef pthread_allocator<_NewType> other; }; #endif }; template <class _T1, class _T2> inline bool operator==(const pthread_allocator<_T1>&, const pthread_allocator<_T2>& a2) { return true; } #ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER template <class _T1, class _T2> inline bool operator!=(const pthread_allocator<_T1>&, const pthread_allocator<_T2>&) { return false; } #endif #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) # if defined (_STLP_USE_RAW_SGI_ALLOCATORS) template <class _Tp> struct _Alloc_traits<_Tp, _Pthread_alloc> { typedef __allocator<_Tp, _Pthread_alloc> allocator_type; }; # endif template <class _Tp, class _Atype> struct _Alloc_traits<_Tp, pthread_allocator<_Atype> > { typedef pthread_allocator<_Tp> allocator_type; }; #endif #if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) template <class _Tp1, class _Tp2> inline pthread_allocator<_Tp2>& __stl_alloc_rebind(pthread_allocator<_Tp1>& __x, const _Tp2*) { return (pthread_allocator<_Tp2>&)__x; } template <class _Tp1, class _Tp2> inline pthread_allocator<_Tp2> __stl_alloc_create(pthread_allocator<_Tp1>&, const _Tp2*) { return pthread_allocator<_Tp2>(); } #endif _STLP_MOVE_TO_PRIV_NAMESPACE template <class _Tp> struct __pthread_alloc_type_traits { typedef typename _IsSTLportClass<pthread_allocator<_Tp> >::_Ret _STLportAlloc; //The default allocator implementation which is recognize thanks to the //__stlport_class inheritance is a stateless object so: typedef _STLportAlloc has_trivial_default_constructor; typedef _STLportAlloc has_trivial_copy_constructor; typedef _STLportAlloc has_trivial_assignment_operator; typedef _STLportAlloc has_trivial_destructor; typedef _STLportAlloc is_POD_type; }; _STLP_MOVE_TO_STD_NAMESPACE #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) template <class _Tp> struct __type_traits<pthread_allocator<_Tp> > : _STLP_PRIV __pthread_alloc_type_traits<_Tp> {}; #else _STLP_TEMPLATE_NULL struct __type_traits<pthread_allocator<char> > : _STLP_PRIV __pthread_alloc_type_traits<char> {}; # if defined (_STLP_HAS_WCHAR_T) _STLP_TEMPLATE_NULL struct __type_traits<pthread_allocator<wchar_t> > : _STLP_PRIV __pthread_alloc_type_traits<wchar_t> {}; # endif # if defined (_STLP_USE_PTR_SPECIALIZATIONS) _STLP_TEMPLATE_NULL struct __type_traits<pthread_allocator<void*> > : _STLP_PRIV __pthread_alloc_type_traits<void*> {}; # endif #endif // // per_thread_allocator<> : this allocator always return memory to the same thread // it was allocated from. // template <class _Tp> class per_thread_allocator { typedef pthread_alloc _S_Alloc; // The underlying allocator. typedef pthread_alloc::__state_type __state_type; public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Tp* pointer; typedef const _Tp* const_pointer; typedef _Tp& reference; typedef const _Tp& const_reference; typedef _Tp value_type; #ifdef _STLP_MEMBER_TEMPLATE_CLASSES template <class _NewType> struct rebind { typedef per_thread_allocator<_NewType> other; }; #endif per_thread_allocator() _STLP_NOTHROW { _M_state = _S_Alloc::_S_get_per_thread_state(); } per_thread_allocator(const per_thread_allocator<_Tp>& __a) _STLP_NOTHROW : _M_state(__a._M_state){} #if defined (_STLP_MEMBER_TEMPLATES) /* && defined (_STLP_FUNCTION_PARTIAL_ORDER) */ template <class _OtherType> per_thread_allocator(const per_thread_allocator<_OtherType>& __a) _STLP_NOTHROW : _M_state(__a._M_state) {} #endif ~per_thread_allocator() _STLP_NOTHROW {} pointer address(reference __x) const { return &__x; } const_pointer address(const_reference __x) const { return &__x; } // __n is permitted to be 0. The C++ standard says nothing about what // the return value is when __n == 0. _Tp* allocate(size_type __n, const void* = 0) { if (__n > max_size()) { __THROW_BAD_ALLOC; } if (__n != 0) { size_type __buf_size = __n * sizeof(value_type); _Tp* __ret = __REINTERPRET_CAST(_Tp*, _S_Alloc::allocate(__buf_size, _M_state)); #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC) if (__ret != 0) { memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size); } #endif return __ret; } else return 0; } void deallocate(pointer __p, size_type __n) { _STLP_ASSERT( (__p == 0) == (__n == 0) ) if (__p != 0) { #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC) memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type)); #endif _S_Alloc::deallocate(__p, __n * sizeof(value_type), _M_state); } } size_type max_size() const _STLP_NOTHROW { return size_t(-1) / sizeof(_Tp); } void construct(pointer __p, const _Tp& __val) { _STLP_PLACEMENT_NEW (__p) _Tp(__val); } void destroy(pointer _p) { _p->~_Tp(); } // state is being kept here __state_type* _M_state; #if defined (_STLP_NO_EXTENSIONS) /* STLport extension giving rounded size of an allocated memory buffer * This method do not have to be part of a user defined allocator implementation * and won't even be called if such a function was granted. */ protected: #endif _Tp* allocate(size_type __n, size_type& __allocated_n) { if (__n > max_size()) { __THROW_BAD_ALLOC; } if (__n != 0) { size_type __buf_size = __n * sizeof(value_type); _Tp* __ret = __REINTERPRET_CAST(value_type*, _S_Alloc::allocate(__buf_size, _M_state)); #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC) if (__ret != 0) { memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size); } #endif __allocated_n = __buf_size / sizeof(value_type); return __ret; } else return 0; } }; _STLP_TEMPLATE_NULL class _STLP_CLASS_DECLSPEC per_thread_allocator<void> { public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef void* pointer; typedef const void* const_pointer; typedef void value_type; #ifdef _STLP_MEMBER_TEMPLATE_CLASSES template <class _NewType> struct rebind { typedef per_thread_allocator<_NewType> other; }; #endif }; template <class _T1, class _T2> inline bool operator==(const per_thread_allocator<_T1>& __a1, const per_thread_allocator<_T2>& __a2) { return __a1._M_state == __a2._M_state; } #ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER template <class _T1, class _T2> inline bool operator!=(const per_thread_allocator<_T1>& __a1, const per_thread_allocator<_T2>& __a2) { return __a1._M_state != __a2._M_state; } #endif #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) template <class _Tp, class _Atype> struct _Alloc_traits<_Tp, per_thread_allocator<_Atype> > { typedef per_thread_allocator<_Tp> allocator_type; }; #endif #if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) template <class _Tp1, class _Tp2> inline per_thread_allocator<_Tp2>& __stl_alloc_rebind(per_thread_allocator<_Tp1>& __x, const _Tp2*) { return (per_thread_allocator<_Tp2>&)__x; } template <class _Tp1, class _Tp2> inline per_thread_allocator<_Tp2> __stl_alloc_create(per_thread_allocator<_Tp1>&, const _Tp2*) { return per_thread_allocator<_Tp2>(); } #endif /* _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE */ _STLP_MOVE_TO_PRIV_NAMESPACE template <class _Tp> struct __perthread_alloc_type_traits { typedef typename _IsSTLportClass<per_thread_allocator<_Tp> >::_Ret _STLportAlloc; //The default allocator implementation which is recognize thanks to the //__stlport_class inheritance is a stateless object so: typedef __false_type has_trivial_default_constructor; typedef _STLportAlloc has_trivial_copy_constructor; typedef _STLportAlloc has_trivial_assignment_operator; typedef _STLportAlloc has_trivial_destructor; typedef __false_type is_POD_type; }; _STLP_MOVE_TO_STD_NAMESPACE #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) template <class _Tp> struct __type_traits<per_thread_allocator<_Tp> > : _STLP_PRIV __perthread_alloc_type_traits<_Tp> {}; #else _STLP_TEMPLATE_NULL struct __type_traits<per_thread_allocator<char> > : _STLP_PRIV __perthread_alloc_type_traits<char> {}; # if defined (_STLP_HAS_WCHAR_T) _STLP_TEMPLATE_NULL struct __type_traits<per_thread_allocator<wchar_t> > : _STLP_PRIV __perthread_alloc_type_traits<wchar_t> {}; # endif # if defined (_STLP_USE_PTR_SPECIALIZATIONS) _STLP_TEMPLATE_NULL struct __type_traits<per_thread_allocator<void*> > : _STLP_PRIV __perthread_alloc_type_traits<void*> {}; # endif #endif _STLP_END_NAMESPACE #endif /* _STLP_PTHREAD_ALLOC */ // Local Variables: // mode:C++ // End:

• ソフトウェア開発
• ホームページ制作
• Doxygen Source Document
• Tcl Source Document