/home/ntakagi/work/STLport-5.1.5/stlport/stl/_threads.h Go to the documentation of this file. /* * Copyright (c) 1997-1999 * Silicon Graphics Computer Systems, Inc. * * 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. * */ // WARNING: This is an internal header file, included by other C++ // standard library headers. You should not attempt to use this header // file directly. #ifndef _STLP_INTERNAL_THREADS_H #define _STLP_INTERNAL_THREADS_H // Supported threading models are native SGI, pthreads, uithreads // (similar to pthreads, but based on an earlier draft of the Posix // threads standard), and Win32 threads. Uithread support by Jochen // Schlick, 1999, and Solaris threads generalized to them. #ifndef _STLP_INTERNAL_CSTDDEF # include <stl/_cstddef.h> #endif #ifndef _STLP_INTERNAL_CSTDLIB # include <stl/_cstdlib.h> #endif // On SUN and Mac OS X gcc, zero-initialization works just fine... #if defined (__sun) || (defined (__GNUC__) && defined(__APPLE__)) # define _STLP_MUTEX_INITIALIZER #endif /* This header defines the following atomic operation that platform should * try to support as much as possible. Atomic operation are exposed as macro * in order to easily test for their existance. They are: * __stl_atomic_t _STLP_ATOMIC_INCREMENT(volatile __stl_atomic_t* __ptr) : * increment *__ptr by 1 and returns the new value * __stl_atomic_t _STLP_ATOMIC_DECREMENT(volatile __stl_atomic_t* __ptr) : * decrement *__ptr by 1 and returns the new value * __stl_atomic_t _STLP_ATOMIC_EXCHANGE(volatile __stl_atomic_t* __target, __stl_atomic_t __val) : * assign __val to *__target and returns former *__target value * void* _STLP_ATOMIC_EXCHANGE_PTR(void* volatile* __target, void* __ptr) : * assign __ptr to *__target and returns former *__target value * __stl_atomic_t _STLP_ATOMIC_ADD(volatile __stl_atomic_t* __target, __stl_atomic_t __val) : * does *__target = *__target + __val and returns the old *__target value */ #if defined (_STLP_WIN32) || defined (__sgi) || defined (_STLP_SPARC_SOLARIS_THREADS) typedef long __stl_atomic_t; #else /* Don't import whole namespace!!!! - ptr */ // # if defined (_STLP_USE_NAMESPACES) && ! defined (_STLP_VENDOR_GLOBAL_CSTD) // // using _STLP_VENDOR_CSTD::size_t; // using namespace _STLP_VENDOR_CSTD; // # endif typedef size_t __stl_atomic_t; #endif #if defined (_STLP_THREADS) # if defined (_STLP_SGI_THREADS) # include <mutex.h> // Hack for SGI o32 compilers. # if !defined(__add_and_fetch) && \ (__mips < 3 || !(defined (_ABIN32) || defined(_ABI64))) # define __add_and_fetch(__l,__v) add_then_test((unsigned long*)__l,__v) # define __test_and_set(__l,__v) test_and_set(__l,__v) # endif /* o32 */ # if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) # define _STLP_ATOMIC_EXCHANGE(__p, __q) test_and_set(__p, __q) # else # define _STLP_ATOMIC_EXCHANGE(__p, __q) __test_and_set((unsigned long*)__p, (unsigned long)__q) # endif # define _STLP_ATOMIC_INCREMENT(__x) __add_and_fetch(__x, 1) # define _STLP_ATOMIC_DECREMENT(__x) __add_and_fetch(__x, (size_t) -1) # elif defined (_STLP_PTHREADS) # include <pthread.h> # if !defined (_STLP_USE_PTHREAD_SPINLOCK) # if defined (PTHREAD_MUTEX_INITIALIZER) && !defined (_STLP_MUTEX_INITIALIZER) && defined (_REENTRANT) # define _STLP_MUTEX_INITIALIZER = { PTHREAD_MUTEX_INITIALIZER } # endif //HPUX variants have (on some platforms optional) non-standard "DCE" pthreads impl # if defined (_DECTHREADS_) && (defined (_PTHREAD_USE_D4) || defined (__hpux)) && !defined (_CMA_SUPPRESS_EXTERNALS_) # define _STLP_PTHREAD_ATTR_DEFAULT pthread_mutexattr_default # else # define _STLP_PTHREAD_ATTR_DEFAULT 0 # endif # else // _STLP_USE_PTHREAD_SPINLOCK # if defined (__OpenBSD__) # include <spinlock.h> # endif # endif // _STLP_USE_PTHREAD_SPINLOCK # if defined (__GNUC__) && defined (__i386__) # if !defined (_STLP_ATOMIC_INCREMENT) inline long _STLP_atomic_increment_gcc_x86(long volatile* p) { long result; __asm__ __volatile__ ("lock; xaddl %1, %0;" :"=m" (*p), "=r" (result) :"m" (*p), "1" (1) :"cc"); return result + 1; } # define _STLP_ATOMIC_INCREMENT(__x) (_STLP_atomic_increment_gcc_x86((long volatile*)__x)) # endif # if !defined (_STLP_ATOMIC_DECREMENT) inline long _STLP_atomic_decrement_gcc_x86(long volatile* p) { long result; __asm__ __volatile__ ("lock; xaddl %1, %0;" :"=m" (*p), "=r" (result) :"m" (*p), "1" (-1) :"cc"); return result - 1; } # define _STLP_ATOMIC_DECREMENT(__x) (_STLP_atomic_decrement_gcc_x86((long volatile*)__x)) # endif # if !defined (_STLP_ATOMIC_ADD) inline long _STLP_atomic_add_gcc_x86(long volatile* p, long addend) { long result; __asm__ __volatile__ ("lock; xaddl %1, %0;" :"=m" (*p), "=r" (result) :"m" (*p), "1" (addend) :"cc"); return result + addend; } # define _STLP_ATOMIC_ADD(__dst, __val) (_STLP_atomic_add_gcc_x86((long volatile*)__dst, (long)__val)) # endif # endif /* if defined(__GNUC__) && defined(__i386__) */ # elif defined (_STLP_WIN32THREADS) # if !defined (_STLP_ATOMIC_INCREMENT) # if !defined (_STLP_NEW_PLATFORM_SDK) # define _STLP_ATOMIC_INCREMENT(__x) InterlockedIncrement(__CONST_CAST(long*, __x)) # define _STLP_ATOMIC_DECREMENT(__x) InterlockedDecrement(__CONST_CAST(long*, __x)) # define _STLP_ATOMIC_EXCHANGE(__x, __y) InterlockedExchange(__CONST_CAST(long*, __x), __y) # else # define _STLP_ATOMIC_INCREMENT(__x) InterlockedIncrement(__x) # define _STLP_ATOMIC_DECREMENT(__x) InterlockedDecrement(__x) # define _STLP_ATOMIC_EXCHANGE(__x, __y) InterlockedExchange(__x, __y) # endif # define _STLP_ATOMIC_EXCHANGE_PTR(__x, __y) STLPInterlockedExchangePointer(__x, __y) /* * The following functionnality is only available since Windows 98, those that are targeting previous OSes * should define _WIN32_WINDOWS to a value lower that the one of Win 98, see Platform SDK documentation for * more informations: */ # if defined (_STLP_NEW_PLATFORM_SDK) && (!defined (_STLP_WIN32_VERSION) || (_STLP_WIN32_VERSION >= 0x0410)) # define _STLP_ATOMIC_ADD(__dst, __val) InterlockedExchangeAdd(__dst, __val) # endif # endif # elif defined (__DECC) || defined (__DECCXX) # include <machine/builtins.h> # define _STLP_ATOMIC_EXCHANGE __ATOMIC_EXCH_LONG # define _STLP_ATOMIC_INCREMENT(__x) __ATOMIC_ADD_LONG(__x, 1) # define _STLP_ATOMIC_DECREMENT(__x) __ATOMIC_ADD_LONG(__x, -1) # elif defined(_STLP_SPARC_SOLARIS_THREADS) # include <stl/_sparc_atomic.h> # elif defined (_STLP_UITHREADS) // this inclusion is potential hazard to bring up all sorts // of old-style headers. Let's assume vendor already know how // to deal with that. # ifndef _STLP_INTERNAL_CTIME # include <stl/_ctime.h> # endif # if defined (_STLP_USE_NAMESPACES) && ! defined (_STLP_VENDOR_GLOBAL_CSTD) using _STLP_VENDOR_CSTD::time_t; # endif # include <synch.h> # include <cstdio> # include <cwchar> # elif defined (_STLP_BETHREADS) # include <OS.h> # include <cassert> # include <stdio.h> # define _STLP_MUTEX_INITIALIZER = { 0 } # elif defined (_STLP_NWTHREADS) # include <nwthread.h> # include <nwsemaph.h> # elif defined(_STLP_OS2THREADS) # if defined (__GNUC__) # define INCL_DOSSEMAPHORES # include <os2.h> # else // This section serves to replace os2.h for VisualAge C++ typedef unsigned long ULONG; # if !defined (__HEV__) /* INCL_SEMAPHORE may also define HEV */ # define __HEV__ typedef ULONG HEV; typedef HEV* PHEV; # endif typedef ULONG APIRET; typedef ULONG HMTX; typedef HMTX* PHMTX; typedef const char* PCSZ; typedef ULONG BOOL32; APIRET _System DosCreateMutexSem(PCSZ pszName, PHEV phev, ULONG flAttr, BOOL32 fState); APIRET _System DosRequestMutexSem(HMTX hmtx, ULONG ulTimeout); APIRET _System DosReleaseMutexSem(HMTX hmtx); APIRET _System DosCloseMutexSem(HMTX hmtx); # define _STLP_MUTEX_INITIALIZER = { 0 } # endif /* GNUC */ # endif #else /* no threads */ # define _STLP_ATOMIC_INCREMENT(__x) ++(*__x) # define _STLP_ATOMIC_DECREMENT(__x) --(*__x) /* We do not grant other atomic operations as they are useless if STLport do not have * to be thread safe */ #endif #if !defined (_STLP_MUTEX_INITIALIZER) # if defined(_STLP_ATOMIC_EXCHANGE) # define _STLP_MUTEX_INITIALIZER = { 0 } # elif defined(_STLP_UITHREADS) # define _STLP_MUTEX_INITIALIZER = { DEFAULTMUTEX } # else # define _STLP_MUTEX_INITIALIZER # endif #endif _STLP_BEGIN_NAMESPACE #if defined (_STLP_THREADS) && !defined (_STLP_USE_PTHREAD_SPINLOCK) // Helper struct. This is a workaround for various compilers that don't // handle static variables in inline functions properly. template <int __inst> struct _STLP_mutex_spin { enum { __low_max = 30, __high_max = 1000 }; // Low if we suspect uniprocessor, high for multiprocessor. static unsigned __max; static unsigned __last; static void _STLP_CALL _M_do_lock(volatile __stl_atomic_t* __lock); static void _STLP_CALL _S_nsec_sleep(int __log_nsec); }; #endif // !_STLP_USE_PTHREAD_SPINLOCK // Locking class. Note that this class *does not have a constructor*. // It must be initialized either statically, with _STLP_MUTEX_INITIALIZER, // or dynamically, by explicitly calling the _M_initialize member function. // (This is similar to the ways that a pthreads mutex can be initialized.) // There are explicit member functions for acquiring and releasing the lock. // There is no constructor because static initialization is essential for // some uses, and only a class aggregate (see section 8.5.1 of the C++ // standard) can be initialized that way. That means we must have no // constructors, no base classes, no virtual functions, and no private or // protected members. // For non-static cases, clients should use _STLP_mutex. struct _STLP_CLASS_DECLSPEC _STLP_mutex_base { #if defined (_STLP_ATOMIC_EXCHANGE) || defined (_STLP_SGI_THREADS) // It should be relatively easy to get this to work on any modern Unix. volatile __stl_atomic_t _M_lock; #endif #if defined (_STLP_THREADS) # if defined (_STLP_ATOMIC_EXCHANGE) inline void _M_initialize() { _M_lock = 0; } inline void _M_destroy() {} void _M_acquire_lock() { _STLP_mutex_spin<0>::_M_do_lock(&_M_lock); } inline void _M_release_lock() { volatile __stl_atomic_t* __lock = &_M_lock; # if defined(_STLP_SGI_THREADS) && defined(__GNUC__) && __mips >= 3 asm("sync"); *__lock = 0; # elif defined(_STLP_SGI_THREADS) && __mips >= 3 && \ (defined (_ABIN32) || defined(_ABI64)) __lock_release(__lock); # elif defined (_STLP_SPARC_SOLARIS_THREADS) # if defined (__WORD64) || defined (__arch64__) || defined (__sparcv9) || defined (__sparcv8plus) asm("membar #StoreStore ; membar #LoadStore"); # else asm(" stbar "); # endif *__lock = 0; # else *__lock = 0; // This is not sufficient on many multiprocessors, since // writes to protected variables and the lock may be reordered. # endif } # elif defined (_STLP_PTHREADS) # if defined (_STLP_USE_PTHREAD_SPINLOCK) # if !defined (__OpenBSD__) pthread_spinlock_t _M_lock; inline void _M_initialize() { pthread_spin_init( &_M_lock, 0 ); } inline void _M_destroy() { pthread_spin_destroy( &_M_lock ); } // sorry, but no static initializer for pthread_spinlock_t; // this will not work for compilers that has problems with call // constructor of static object... // _STLP_mutex_base() // { pthread_spin_init( &_M_lock, 0 ); } // ~_STLP_mutex_base() // { pthread_spin_destroy( &_M_lock ); } inline void _M_acquire_lock() { pthread_spin_lock( &_M_lock ); } inline void _M_release_lock() { pthread_spin_unlock( &_M_lock ); } # else // __OpenBSD__ spinlock_t _M_lock; inline void _M_initialize() { _SPINLOCK_INIT( &_M_lock ); } inline void _M_destroy() { } inline void _M_acquire_lock() { _SPINLOCK( &_M_lock ); } inline void _M_release_lock() { _SPINUNLOCK( &_M_lock ); } # endif // __OpenBSD__ # else // !_STLP_USE_PTHREAD_SPINLOCK pthread_mutex_t _M_lock; inline void _M_initialize() { pthread_mutex_init(&_M_lock,_STLP_PTHREAD_ATTR_DEFAULT); } inline void _M_destroy() { pthread_mutex_destroy(&_M_lock); } inline void _M_acquire_lock() { # if defined ( __hpux ) && ! defined (PTHREAD_MUTEX_INITIALIZER) if (!_M_lock.field1) _M_initialize(); # endif pthread_mutex_lock(&_M_lock); } inline void _M_release_lock() { pthread_mutex_unlock(&_M_lock); } # endif // !_STLP_USE_PTHREAD_SPINLOCK # elif defined (_STLP_UITHREADS) mutex_t _M_lock; inline void _M_initialize() { mutex_init(&_M_lock, 0, NULL); } inline void _M_destroy() { mutex_destroy(&_M_lock); } inline void _M_acquire_lock() { mutex_lock(&_M_lock); } inline void _M_release_lock() { mutex_unlock(&_M_lock); } # elif defined (_STLP_OS2THREADS) HMTX _M_lock; inline void _M_initialize() { DosCreateMutexSem(NULL, &_M_lock, 0, false); } inline void _M_destroy() { DosCloseMutexSem(_M_lock); } inline void _M_acquire_lock() { if (!_M_lock) _M_initialize(); DosRequestMutexSem(_M_lock, SEM_INDEFINITE_WAIT); } inline void _M_release_lock() { DosReleaseMutexSem(_M_lock); } # elif defined (_STLP_BETHREADS) sem_id sem; inline void _M_initialize() { sem = create_sem(1, "STLPort"); assert(sem > 0); } inline void _M_destroy() { int t = delete_sem(sem); assert(t == B_NO_ERROR); } inline void _M_acquire_lock(); inline void _M_release_lock() { status_t t = release_sem(sem); assert(t == B_NO_ERROR); } # elif defined (_STLP_NWTHREADS) LONG _M_lock; inline void _M_initialize() { _M_lock = OpenLocalSemaphore(1); } inline void _M_destroy() { CloseLocalSemaphore(_M_lock); } inline void _M_acquire_lock() { WaitOnLocalSemaphore(_M_lock); } inline void _M_release_lock() { SignalLocalSemaphore(_M_lock); } # else //*ty 11/24/2001 - added configuration check # error "Unknown thread facility configuration" # endif #else /* No threads */ inline void _M_initialize() {} inline void _M_destroy() {} inline void _M_acquire_lock() {} inline void _M_release_lock() {} #endif // _STLP_PTHREADS }; // Locking class. The constructor initializes the lock, the destructor destroys it. // Well - behaving class, does not need static initializer class _STLP_CLASS_DECLSPEC _STLP_mutex : public _STLP_mutex_base { public: inline _STLP_mutex () { _M_initialize(); } inline ~_STLP_mutex () { _M_destroy(); } private: _STLP_mutex(const _STLP_mutex&); void operator=(const _STLP_mutex&); }; // A locking class that uses _STLP_STATIC_MUTEX. The constructor takes // a reference to an _STLP_STATIC_MUTEX, and acquires a lock. The destructor // releases the lock. // It's not clear that this is exactly the right functionality. // It will probably change in the future. struct _STLP_CLASS_DECLSPEC _STLP_auto_lock { _STLP_auto_lock(_STLP_STATIC_MUTEX& __lock) : _M_lock(__lock) { _M_lock._M_acquire_lock(); } ~_STLP_auto_lock() { _M_lock._M_release_lock(); } private: _STLP_STATIC_MUTEX& _M_lock; void operator=(const _STLP_auto_lock&); _STLP_auto_lock(const _STLP_auto_lock&); }; /* * Class _Refcount_Base provides a type, __stl_atomic_t, a data member, * _M_ref_count, and member functions _M_incr and _M_decr, which perform * atomic preincrement/predecrement. The constructor initializes * _M_ref_count. */ class _STLP_CLASS_DECLSPEC _Refcount_Base { // The data member _M_ref_count #if defined (__DMC__) public: #endif _STLP_VOLATILE __stl_atomic_t _M_ref_count; #if defined (_STLP_THREADS) && \ (!defined (_STLP_ATOMIC_INCREMENT) || !defined (_STLP_ATOMIC_DECREMENT) || \ (defined (_STLP_WIN32_VERSION) && (_STLP_WIN32_VERSION <= 0x0400))) # define _STLP_USE_MUTEX _STLP_mutex _M_mutex; #endif public: // Constructor _Refcount_Base(__stl_atomic_t __n) : _M_ref_count(__n) {} // _M_incr and _M_decr #if defined (_STLP_THREADS) # if !defined (_STLP_USE_MUTEX) __stl_atomic_t _M_incr() { return _STLP_ATOMIC_INCREMENT(&_M_ref_count); } __stl_atomic_t _M_decr() { return _STLP_ATOMIC_DECREMENT(&_M_ref_count); } # else # undef _STLP_USE_MUTEX __stl_atomic_t _M_incr() { _STLP_auto_lock l(_M_mutex); return ++_M_ref_count; } __stl_atomic_t _M_decr() { _STLP_auto_lock l(_M_mutex); return --_M_ref_count; } # endif #else /* No threads */ __stl_atomic_t _M_incr() { return ++_M_ref_count; } __stl_atomic_t _M_decr() { return --_M_ref_count; } #endif }; /* Atomic swap on __stl_atomic_t * This is guaranteed to behave as though it were atomic only if all * possibly concurrent updates use _Atomic_swap. * In some cases the operation is emulated with a lock. * Idem for _Atomic_swap_ptr */ /* Helper struct to handle following cases: * - on platforms where sizeof(__stl_atomic_t) == sizeof(void*) atomic * exchange can be done on pointers * - on platform without atomic operation swap is done in a critical section, * portable but inefficient. */ template <int __use_ptr_atomic_swap> class _Atomic_swap_struct { public: #if defined (_STLP_THREADS) && \ !defined (_STLP_ATOMIC_EXCHANGE) && \ (defined (_STLP_PTHREADS) || defined (_STLP_UITHREADS) || defined (_STLP_OS2THREADS) || \ defined (_STLP_USE_PTHREAD_SPINLOCK) || defined (_STLP_NWTHREADS)) # define _STLP_USE_ATOMIC_SWAP_MUTEX static _STLP_STATIC_MUTEX _S_swap_lock; #endif static __stl_atomic_t _S_swap(_STLP_VOLATILE __stl_atomic_t* __p, __stl_atomic_t __q) { #if defined (_STLP_THREADS) # if defined (_STLP_ATOMIC_EXCHANGE) return _STLP_ATOMIC_EXCHANGE(__p, __q); # elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX) _S_swap_lock._M_acquire_lock(); __stl_atomic_t __result = *__p; *__p = __q; _S_swap_lock._M_release_lock(); return __result; # else # error Missing atomic swap implementation # endif #else /* no threads */ __stl_atomic_t __result = *__p; *__p = __q; return __result; #endif // _STLP_THREADS } static void* _S_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) { #if defined (_STLP_THREADS) # if defined (_STLP_ATOMIC_EXCHANGE_PTR) return _STLP_ATOMIC_EXCHANGE_PTR(__p, __q); # elif defined (_STLP_ATOMIC_EXCHANGE) _STLP_STATIC_ASSERT(sizeof(__stl_atomic_t) == sizeof(void*)) return __REINTERPRET_CAST(void*, _STLP_ATOMIC_EXCHANGE(__REINTERPRET_CAST(volatile __stl_atomic_t*, __p), __REINTERPRET_CAST(__stl_atomic_t, __q)) ); # elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX) _S_swap_lock._M_acquire_lock(); void *__result = *__p; *__p = __q; _S_swap_lock._M_release_lock(); return __result; # else # error Missing pointer atomic swap implementation # endif #else /* no thread */ void *__result = *__p; *__p = __q; return __result; #endif } }; _STLP_TEMPLATE_NULL class _Atomic_swap_struct<0> { public: #if defined (_STLP_THREADS) && \ (!defined (_STLP_ATOMIC_EXCHANGE) || !defined (_STLP_ATOMIC_EXCHANGE_PTR)) && \ (defined (_STLP_PTHREADS) || defined (_STLP_UITHREADS) || defined (_STLP_OS2THREADS) || \ defined (_STLP_USE_PTHREAD_SPINLOCK) || defined (_STLP_NWTHREADS)) # define _STLP_USE_ATOMIC_SWAP_MUTEX static _STLP_STATIC_MUTEX _S_swap_lock; #endif static __stl_atomic_t _S_swap(_STLP_VOLATILE __stl_atomic_t* __p, __stl_atomic_t __q) { #if defined (_STLP_THREADS) # if defined (_STLP_ATOMIC_EXCHANGE) return _STLP_ATOMIC_EXCHANGE(__p, __q); # elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX) /* This should be portable, but performance is expected * to be quite awful. This really needs platform specific * code. */ _S_swap_lock._M_acquire_lock(); __stl_atomic_t __result = *__p; *__p = __q; _S_swap_lock._M_release_lock(); return __result; # else # error Missing atomic swap implementation # endif #else /* no threads */ __stl_atomic_t __result = *__p; *__p = __q; return __result; #endif // _STLP_THREADS } static void* _S_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) { #if defined (_STLP_THREADS) # if defined (_STLP_ATOMIC_EXCHANGE_PTR) return _STLP_ATOMIC_EXCHANGE_PTR(__p, __q); # elif defined (_STLP_ATOMIC_EXCHANGE) _STLP_STATIC_ASSERT(sizeof(__stl_atomic_t) == sizeof(void*)) return __REINTERPRET_CAST(void*, _STLP_ATOMIC_EXCHANGE(__REINTERPRET_CAST(volatile __stl_atomic_t*, __p), __REINTERPRET_CAST(__stl_atomic_t, __q)) ); # elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX) _S_swap_lock._M_acquire_lock(); void *__result = *__p; *__p = __q; _S_swap_lock._M_release_lock(); return __result; # else # error Missing pointer atomic swap implementation # endif #else /* no thread */ void *__result = *__p; *__p = __q; return __result; #endif } }; #if defined (_STLP_MSVC) && (_STLP_MSVC == 1300) # pragma warning (push) # pragma warning (disable : 4189) //__use_ptr_atomic_swap initialized but not used #endif inline __stl_atomic_t _STLP_CALL _Atomic_swap(_STLP_VOLATILE __stl_atomic_t * __p, __stl_atomic_t __q) { const int __use_ptr_atomic_swap = sizeof(__stl_atomic_t) == sizeof(void*); return _Atomic_swap_struct<__use_ptr_atomic_swap>::_S_swap(__p, __q); } inline void* _STLP_CALL _Atomic_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) { const int __use_ptr_atomic_swap = sizeof(__stl_atomic_t) == sizeof(void*); return _Atomic_swap_struct<__use_ptr_atomic_swap>::_S_swap_ptr(__p, __q); } #if defined (_STLP_MSVC) && (_STLP_MSVC == 1300) # pragma warning (pop) #endif #if defined (_STLP_BETHREADS) template <int __inst> struct _STLP_beos_static_lock_data { static bool is_init; struct mutex_t : public _STLP_mutex { mutex_t() { _STLP_beos_static_lock_data<0>::is_init = true; } ~mutex_t() { _STLP_beos_static_lock_data<0>::is_init = false; } }; static mutex_t mut; }; template <int __inst> bool _STLP_beos_static_lock_data<__inst>::is_init = false; template <int __inst> typename _STLP_beos_static_lock_data<__inst>::mutex_t _STLP_beos_static_lock_data<__inst>::mut; inline void _STLP_mutex_base::_M_acquire_lock() { if (sem == 0) { // we need to initialise on demand here // to prevent race conditions use our global // mutex if it's available: if (_STLP_beos_static_lock_data<0>::is_init) { _STLP_auto_lock al(_STLP_beos_static_lock_data<0>::mut); if (sem == 0) _M_initialize(); } else { // no lock available, we must still be // in startup code, THERE MUST BE ONE THREAD // ONLY active at this point. _M_initialize(); } } status_t t; t = acquire_sem(sem); assert(t == B_NO_ERROR); } #endif _STLP_END_NAMESPACE #if !defined (_STLP_LINK_TIME_INSTANTIATION) # include <stl/_threads.c> #endif #endif /* _STLP_INTERNAL_THREADS_H */ // Local Variables: // mode:C++ // End:

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