lib/3rdparty/stlport/stlport/stl/_threads.h

   1 /*
   2  * Copyright (c) 1997-1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  *
  17  */
  18
  19 // WARNING: This is an internal header file, included by other C++
  20 // standard library headers.  You should not attempt to use this header
  21 // file directly.
  22
  23
  24 #ifndef _STLP_INTERNAL_THREADS_H
  25 #define _STLP_INTERNAL_THREADS_H
  26
  27 // Supported threading models are native SGI, pthreads, uithreads
  28 // (similar to pthreads, but based on an earlier draft of the Posix
  29 // threads standard), and Win32 threads.  Uithread support by Jochen
  30 // Schlick, 1999, and Solaris threads generalized to them.
  31
  32 #ifndef _STLP_INTERNAL_CSTDDEF
  33 #  include <stl/_cstddef.h>
  34 #endif
  35
  36 #ifndef _STLP_INTERNAL_CSTDLIB
  37 #  include <stl/_cstdlib.h>
  38 #endif
  39
  40 // On SUN and Mac OS X gcc, zero-initialization works just fine...
  41 #if defined (__sun) || (defined (__GNUC__) && defined(__APPLE__))
  42 #  define _STLP_MUTEX_INITIALIZER
  43 #endif
  44
  45 /* This header defines the following atomic operation that platform should
  46  * try to support as much as possible. Atomic operation are exposed as macro
  47  * in order to easily test for their existance. They are:
  48  * __stl_atomic_t _STLP_ATOMIC_INCREMENT(volatile __stl_atomic_t* __ptr) :
  49  * increment *__ptr by 1 and returns the new value
  50  * __stl_atomic_t _STLP_ATOMIC_DECREMENT(volatile __stl_atomic_t* __ptr) :
  51  * decrement  *__ptr by 1 and returns the new value
  52  * __stl_atomic_t _STLP_ATOMIC_EXCHANGE(volatile __stl_atomic_t* __target, __stl_atomic_t __val) :
  53  * assign __val to *__target and returns former *__target value
  54  * void* _STLP_ATOMIC_EXCHANGE_PTR(void* volatile* __target, void* __ptr) :
  55  * assign __ptr to *__target and returns former *__target value
  56  */
  57
  58 #if defined (_STLP_THREADS)
  59
  60 #  if defined (_STLP_SGI_THREADS)
  61
  62 #    include <mutex.h>
  63 // Hack for SGI o32 compilers.
  64 #    if !defined(__add_and_fetch) && \
  65         (__mips < 3 || !(defined (_ABIN32) || defined(_ABI64)))
  66 #      define __add_and_fetch(__l,__v) add_then_test((unsigned long*)__l,__v)
  67 #      define __test_and_set(__l,__v)  test_and_set(__l,__v)
  68 #    endif /* o32 */
  69
  70 #    if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64))
  71 #      define _STLP_ATOMIC_EXCHANGE(__p, __q) test_and_set(__p, __q)
  72 #    else
  73 #      define _STLP_ATOMIC_EXCHANGE(__p, __q) __test_and_set((unsigned long*)__p, (unsigned long)__q)
  74 #    endif
  75
  76 #    define _STLP_ATOMIC_INCREMENT(__x) __add_and_fetch(__x, 1)
  77 #    define _STLP_ATOMIC_DECREMENT(__x) __add_and_fetch(__x, (size_t) -1)
  78 typedef long __stl_atomic_t;
  79
  80 #  elif defined (_STLP_PTHREADS)
  81
  82 #    include <pthread.h>
  83 #    if !defined (_STLP_USE_PTHREAD_SPINLOCK)
  84 #      if defined (PTHREAD_MUTEX_INITIALIZER) && !defined (_STLP_MUTEX_INITIALIZER) && defined (_REENTRANT)
  85 #        define _STLP_MUTEX_INITIALIZER = { PTHREAD_MUTEX_INITIALIZER }
  86 #      endif
  87 //HPUX variants have (on some platforms optional) non-standard "DCE" pthreads impl
  88 #      if defined (_DECTHREADS_) && (defined (_PTHREAD_USE_D4) || defined (__hpux)) && !defined (_CMA_SUPPRESS_EXTERNALS_)
  89 #        define _STLP_PTHREAD_ATTR_DEFAULT pthread_mutexattr_default
  90 #      else
  91 #        define _STLP_PTHREAD_ATTR_DEFAULT 0
  92 #      endif
  93 #    else
  94 #      if defined (__OpenBSD__)
  95 #        include <spinlock.h>
  96 #      endif
  97 #    endif
  98
  99 #    if defined (__GNUC__) && defined (__i386__)
 100 #      if !defined (_STLP_ATOMIC_INCREMENT)
 101 inline long _STLP_atomic_increment_gcc_x86(long volatile* p) {
 102   long result;
 103   __asm__ __volatile__
 104     ("lock; xaddl  %1, %0;"
 105     :"=m" (*p), "=r" (result)
 106     :"m" (*p),  "1"  (1)
 107     :"cc");
 108   return result + 1;
 109 }
 110 #        define _STLP_ATOMIC_INCREMENT(__x) (_STLP_atomic_increment_gcc_x86((long volatile*)__x))
 111 #      endif
 112
 113 #      if !defined (_STLP_ATOMIC_DECREMENT)
 114 inline long _STLP_atomic_decrement_gcc_x86(long volatile* p) {
 115   long result;
 116   __asm__ __volatile__
 117     ("lock; xaddl  %1, %0;"
 118     :"=m" (*p), "=r" (result)
 119     :"m" (*p),  "1"  (-1)
 120     :"cc");
 121   return result - 1;
 122 }
 123 #        define _STLP_ATOMIC_DECREMENT(__x) (_STLP_atomic_decrement_gcc_x86((long volatile*)__x))
 124 #      endif
 125 typedef long __stl_atomic_t;
 126 #    else
 127 typedef size_t __stl_atomic_t;
 128 #    endif /* if defined(__GNUC__) && defined(__i386__) */
 129
 130 #  elif defined (_STLP_WIN32THREADS)
 131
 132 #    if !defined (_STLP_ATOMIC_INCREMENT)
 133 #      if !defined (_STLP_NEW_PLATFORM_SDK)
 134 #        define _STLP_ATOMIC_INCREMENT(__x)           InterlockedIncrement(__CONST_CAST(long*, __x))
 135 #        define _STLP_ATOMIC_DECREMENT(__x)           InterlockedDecrement(__CONST_CAST(long*, __x))
 136 #        define _STLP_ATOMIC_EXCHANGE(__x, __y)       InterlockedExchange(__CONST_CAST(long*, __x), __y)
 137 #      else
 138 #        define _STLP_ATOMIC_INCREMENT(__x)           InterlockedIncrement(__x)
 139 #        define _STLP_ATOMIC_DECREMENT(__x)           InterlockedDecrement(__x)
 140 #        define _STLP_ATOMIC_EXCHANGE(__x, __y)       InterlockedExchange(__x, __y)
 141 #      endif
 142 #      define _STLP_ATOMIC_EXCHANGE_PTR(__x, __y)     STLPInterlockedExchangePointer(__x, __y)
 143 #    endif
 144 typedef long __stl_atomic_t;
 145
 146 #  elif defined (__DECC) || defined (__DECCXX)
 147
 148 #    include <machine/builtins.h>
 149 #    define _STLP_ATOMIC_EXCHANGE __ATOMIC_EXCH_LONG
 150 #    define _STLP_ATOMIC_INCREMENT(__x) __ATOMIC_ADD_LONG(__x, 1)
 151 #    define _STLP_ATOMIC_DECREMENT(__x) __ATOMIC_ADD_LONG(__x, -1)
 152 typedef long __stl_atomic_t;
 153
 154 #  elif defined (_STLP_SPARC_SOLARIS_THREADS)
 155
 156 typedef long __stl_atomic_t;
 157 #    include <stl/_sparc_atomic.h>
 158
 159 #  elif defined (_STLP_UITHREADS)
 160
 161 // this inclusion is potential hazard to bring up all sorts
 162 // of old-style headers. Let's assume vendor already know how
 163 // to deal with that.
 164 #    ifndef _STLP_INTERNAL_CTIME
 165 #      include <stl/_ctime.h>
 166 #    endif
 167 #    if defined (_STLP_USE_NAMESPACES) && ! defined (_STLP_VENDOR_GLOBAL_CSTD)
 168 using _STLP_VENDOR_CSTD::time_t;
 169 #    endif
 170 #    include <synch.h>
 171 #    ifndef _STLP_INTERNAL_CSTDIO
 172 #      include <stl/_cstdio.h>
 173 #    endif
 174 #    ifndef _STLP_INTERNAL_CWCHAR
 175 #      include <stl/_cwchar.h>
 176 #    endif
 177 typedef size_t __stl_atomic_t;
 178
 179 #  elif defined (_STLP_BETHREADS)
 180
 181 #    include <OS.h>
 182 #    include <cassert>
 183 #    include <stdio.h>
 184 #    define _STLP_MUTEX_INITIALIZER = { 0 }
 185 typedef size_t __stl_atomic_t;
 186
 187 #  elif defined (_STLP_NWTHREADS)
 188
 189 #    include <nwthread.h>
 190 #    include <nwsemaph.h>
 191 typedef size_t __stl_atomic_t;
 192
 193 #  elif defined(_STLP_OS2THREADS)
 194
 195 #    if defined (__GNUC__)
 196 #      define INCL_DOSSEMAPHORES
 197 #      include <os2.h>
 198 #    else
 199 // This section serves to replace os2.h for VisualAge C++
 200   typedef unsigned long ULONG;
 201 #      if !defined (__HEV__)  /* INCL_SEMAPHORE may also define HEV */
 202 #        define __HEV__
 203   typedef ULONG HEV;
 204   typedef HEV*  PHEV;
 205 #      endif
 206   typedef ULONG APIRET;
 207   typedef ULONG HMTX;
 208   typedef HMTX*  PHMTX;
 209   typedef const char*  PCSZ;
 210   typedef ULONG BOOL32;
 211   APIRET _System DosCreateMutexSem(PCSZ pszName, PHEV phev, ULONG flAttr, BOOL32 fState);
 212   APIRET _System DosRequestMutexSem(HMTX hmtx, ULONG ulTimeout);
 213   APIRET _System DosReleaseMutexSem(HMTX hmtx);
 214   APIRET _System DosCloseMutexSem(HMTX hmtx);
 215 #      define _STLP_MUTEX_INITIALIZER = { 0 }
 216 #    endif /* GNUC */
 217 typedef size_t __stl_atomic_t;
 218
 219 #  else
 220
 221 typedef size_t __stl_atomic_t;
 222
 223 #  endif
 224
 225 #else
 226 /* no threads */
 227 #  define _STLP_ATOMIC_INCREMENT(__x) ++(*__x)
 228 #  define _STLP_ATOMIC_DECREMENT(__x) --(*__x)
 229 /* We do not grant other atomic operations as they are useless if STLport do not have
 230  * to be thread safe
 231  */
 232 typedef size_t __stl_atomic_t;
 233 #endif
 234
 235 #if !defined (_STLP_MUTEX_INITIALIZER)
 236 #  if defined(_STLP_ATOMIC_EXCHANGE)
 237 #    define _STLP_MUTEX_INITIALIZER = { 0 }
 238 #  elif defined(_STLP_UITHREADS)
 239 #    define _STLP_MUTEX_INITIALIZER = { DEFAULTMUTEX }
 240 #  else
 241 #    define _STLP_MUTEX_INITIALIZER
 242 #  endif
 243 #endif
 244
 245 _STLP_BEGIN_NAMESPACE
 246
 247 #if defined (_STLP_THREADS) && !defined (_STLP_USE_PTHREAD_SPINLOCK)
 248 // Helper struct.  This is a workaround for various compilers that don't
 249 // handle static variables in inline functions properly.
 250 template <int __inst>
 251 struct _STLP_mutex_spin {
 252   enum { __low_max = 30, __high_max = 1000 };
 253   // Low if we suspect uniprocessor, high for multiprocessor.
 254   static unsigned __max;
 255   static unsigned __last;
 256   static void _STLP_CALL _M_do_lock(volatile __stl_atomic_t* __lock);
 257   static void _STLP_CALL _S_nsec_sleep(int __log_nsec, unsigned int& __iteration);
 258 };
 259 #endif // !_STLP_USE_PTHREAD_SPINLOCK
 260
 261 // Locking class.  Note that this class *does not have a constructor*.
 262 // It must be initialized either statically, with _STLP_MUTEX_INITIALIZER,
 263 // or dynamically, by explicitly calling the _M_initialize member function.
 264 // (This is similar to the ways that a pthreads mutex can be initialized.)
 265 // There are explicit member functions for acquiring and releasing the lock.
 266
 267 // There is no constructor because static initialization is essential for
 268 // some uses, and only a class aggregate (see section 8.5.1 of the C++
 269 // standard) can be initialized that way.  That means we must have no
 270 // constructors, no base classes, no virtual functions, and no private or
 271 // protected members.
 272
 273 // For non-static cases, clients should use  _STLP_mutex.
 274
 275 struct _STLP_CLASS_DECLSPEC _STLP_mutex_base {
 276 #if defined (_STLP_ATOMIC_EXCHANGE) || defined (_STLP_SGI_THREADS)
 277   // It should be relatively easy to get this to work on any modern Unix.
 278   volatile __stl_atomic_t _M_lock;
 279 #endif
 280
 281 #if defined (_STLP_THREADS)
 282 #  if defined (_STLP_ATOMIC_EXCHANGE)
 283   inline void _M_initialize() { _M_lock = 0; }
 284   inline void _M_destroy() {}
 285
 286   void _M_acquire_lock() {
 287     _STLP_mutex_spin<0>::_M_do_lock(&_M_lock);
 288   }
 289
 290   inline void _M_release_lock() {
 291     volatile __stl_atomic_t* __lock = &_M_lock;
 292 #    if defined(_STLP_SGI_THREADS) && defined(__GNUC__) && __mips >= 3
 293     asm("sync");
 294     *__lock = 0;
 295 #    elif defined(_STLP_SGI_THREADS) && __mips >= 3 && \
 296          (defined (_ABIN32) || defined(_ABI64))
 297     __lock_release(__lock);
 298 #    elif defined (_STLP_SPARC_SOLARIS_THREADS)
 299 #      if defined (__WORD64) || defined (__arch64__) || defined (__sparcv9) || defined (__sparcv8plus)
 300     asm("membar #StoreStore ; membar #LoadStore");
 301 #      else
 302     asm(" stbar ");
 303 #      endif
 304     *__lock = 0;
 305 #    else
 306     *__lock = 0;
 307     // This is not sufficient on many multiprocessors, since
 308     // writes to protected variables and the lock may be reordered.
 309 #    endif
 310   }
 311 #  elif defined (_STLP_PTHREADS)
 312 #    if defined (_STLP_USE_PTHREAD_SPINLOCK)
 313 #      if !defined (__OpenBSD__)
 314   pthread_spinlock_t _M_lock;
 315   inline void _M_initialize() { pthread_spin_init( &_M_lock, 0 ); }
 316   inline void _M_destroy() { pthread_spin_destroy( &_M_lock ); }
 317
 318   // sorry, but no static initializer for pthread_spinlock_t;
 319   // this will not work for compilers that has problems with call
 320   // constructor of static object...
 321
 322   // _STLP_mutex_base()
 323   //   { pthread_spin_init( &_M_lock, 0 ); }
 324
 325   // ~_STLP_mutex_base()
 326   //   { pthread_spin_destroy( &_M_lock ); }
 327
 328   inline void _M_acquire_lock() { pthread_spin_lock( &_M_lock ); }
 329   inline void _M_release_lock() { pthread_spin_unlock( &_M_lock ); }
 330 #      else // __OpenBSD__
 331   spinlock_t _M_lock;
 332   inline void _M_initialize() { _SPINLOCK_INIT( &_M_lock ); }
 333   inline void _M_destroy() { }
 334   inline void _M_acquire_lock() { _SPINLOCK( &_M_lock ); }
 335   inline void _M_release_lock() { _SPINUNLOCK( &_M_lock ); }
 336 #      endif // __OpenBSD__
 337 #    else // !_STLP_USE_PTHREAD_SPINLOCK
 338   pthread_mutex_t _M_lock;
 339   inline void _M_initialize()
 340   { pthread_mutex_init(&_M_lock,_STLP_PTHREAD_ATTR_DEFAULT); }
 341   inline void _M_destroy()
 342   { pthread_mutex_destroy(&_M_lock); }
 343   inline void _M_acquire_lock() {
 344 #      if defined ( __hpux ) && ! defined (PTHREAD_MUTEX_INITIALIZER)
 345     if (!_M_lock.field1)  _M_initialize();
 346 #      endif
 347     pthread_mutex_lock(&_M_lock);
 348   }
 349   inline void _M_release_lock() { pthread_mutex_unlock(&_M_lock); }
 350 #    endif // !_STLP_USE_PTHREAD_SPINLOCK
 351
 352 #  elif defined (_STLP_UITHREADS)
 353   mutex_t _M_lock;
 354   inline void _M_initialize()
 355   { mutex_init(&_M_lock, 0, NULL); }
 356   inline void _M_destroy()
 357   { mutex_destroy(&_M_lock); }
 358   inline void _M_acquire_lock() { mutex_lock(&_M_lock); }
 359   inline void _M_release_lock() { mutex_unlock(&_M_lock); }
 360
 361 #  elif defined (_STLP_OS2THREADS)
 362   HMTX _M_lock;
 363   inline void _M_initialize() { DosCreateMutexSem(NULL, &_M_lock, 0, false); }
 364   inline void _M_destroy() { DosCloseMutexSem(_M_lock); }
 365   inline void _M_acquire_lock() {
 366     if (!_M_lock) _M_initialize();
 367     DosRequestMutexSem(_M_lock, SEM_INDEFINITE_WAIT);
 368   }
 369   inline void _M_release_lock() { DosReleaseMutexSem(_M_lock); }
 370 #  elif defined (_STLP_BETHREADS)
 371   sem_id sem;
 372   inline void _M_initialize() {
 373     sem = create_sem(1, "STLPort");
 374     assert(sem > 0);
 375   }
 376   inline void _M_destroy() {
 377     int t = delete_sem(sem);
 378     assert(t == B_NO_ERROR);
 379   }
 380   inline void _M_acquire_lock();
 381   inline void _M_release_lock() {
 382     status_t t = release_sem(sem);
 383     assert(t == B_NO_ERROR);
 384   }
 385 #  elif defined (_STLP_NWTHREADS)
 386   LONG _M_lock;
 387   inline void _M_initialize()
 388   { _M_lock = OpenLocalSemaphore(1); }
 389   inline void _M_destroy()
 390   { CloseLocalSemaphore(_M_lock); }
 391   inline void _M_acquire_lock()
 392   { WaitOnLocalSemaphore(_M_lock); }
 393   inline void _M_release_lock() { SignalLocalSemaphore(_M_lock); }
 394 #  else      //*ty 11/24/2001 - added configuration check
 395 #    error "Unknown thread facility configuration"
 396 #  endif
 397 #else /* No threads */
 398   inline void _M_initialize() {}
 399   inline void _M_destroy() {}
 400   inline void _M_acquire_lock() {}
 401   inline void _M_release_lock() {}
 402 #endif // _STLP_PTHREADS
 403 };
 404
 405 // Locking class.  The constructor initializes the lock, the destructor destroys it.
 406 // Well - behaving class, does not need static initializer
 407
 408 class _STLP_CLASS_DECLSPEC _STLP_mutex : public _STLP_mutex_base {
 409   public:
 410     inline _STLP_mutex () { _M_initialize(); }
 411     inline ~_STLP_mutex () { _M_destroy(); }
 412   private:
 413     _STLP_mutex(const _STLP_mutex&);
 414     void operator=(const _STLP_mutex&);
 415 };
 416
 417 // A locking class that uses _STLP_STATIC_MUTEX.  The constructor takes
 418 // a reference to an _STLP_STATIC_MUTEX, and acquires a lock.  The destructor
 419 // releases the lock.
 420 // It's not clear that this is exactly the right functionality.
 421 // It will probably change in the future.
 422
 423 struct _STLP_CLASS_DECLSPEC _STLP_auto_lock {
 424   _STLP_auto_lock(_STLP_STATIC_MUTEX& __lock) : _M_lock(__lock)
 425   { _M_lock._M_acquire_lock(); }
 426   ~_STLP_auto_lock()
 427   { _M_lock._M_release_lock(); }
 428
 429 private:
 430   _STLP_STATIC_MUTEX& _M_lock;
 431   void operator=(const _STLP_auto_lock&);
 432   _STLP_auto_lock(const _STLP_auto_lock&);
 433 };
 434
 435 /*
 436  * Class _Refcount_Base provides a type, __stl_atomic_t, a data member,
 437  * _M_ref_count, and member functions _M_incr and _M_decr, which perform
 438  * atomic preincrement/predecrement.  The constructor initializes
 439  * _M_ref_count.
 440  */
 441 class _STLP_CLASS_DECLSPEC _Refcount_Base {
 442   // The data member _M_ref_count
 443 #if defined (__DMC__)
 444 public:
 445 #endif
 446   _STLP_VOLATILE __stl_atomic_t _M_ref_count;
 447
 448 #if defined (_STLP_THREADS) && \
 449    (!defined (_STLP_ATOMIC_INCREMENT) || !defined (_STLP_ATOMIC_DECREMENT) || \
 450     defined (_STLP_WIN95_LIKE))
 451 #  define _STLP_USE_MUTEX
 452   _STLP_mutex _M_mutex;
 453 #endif
 454
 455   public:
 456   // Constructor
 457   _Refcount_Base(__stl_atomic_t __n) : _M_ref_count(__n) {}
 458 #if defined (__BORLANDC__)
 459   ~_Refcount_Base(){};
 460 #endif
 461
 462   // _M_incr and _M_decr
 463 #if defined (_STLP_THREADS)
 464 #  if !defined (_STLP_USE_MUTEX)
 465    __stl_atomic_t _M_incr() { return _STLP_ATOMIC_INCREMENT(&_M_ref_count); }
 466    __stl_atomic_t _M_decr() { return _STLP_ATOMIC_DECREMENT(&_M_ref_count); }
 467 #  else
 468 #    undef _STLP_USE_MUTEX
 469   __stl_atomic_t _M_incr() {
 470     _STLP_auto_lock l(_M_mutex);
 471     return ++_M_ref_count;
 472   }
 473   __stl_atomic_t _M_decr() {
 474     _STLP_auto_lock l(_M_mutex);
 475     return --_M_ref_count;
 476   }
 477 #  endif
 478 #else  /* No threads */
 479   __stl_atomic_t _M_incr() { return ++_M_ref_count; }
 480   __stl_atomic_t _M_decr() { return --_M_ref_count; }
 481 #endif
 482 };
 483
 484 /* Atomic swap on __stl_atomic_t
 485  * This is guaranteed to behave as though it were atomic only if all
 486  * possibly concurrent updates use _Atomic_swap.
 487  * In some cases the operation is emulated with a lock.
 488  * Idem for _Atomic_swap_ptr
 489  */
 490 /* Helper struct to handle following cases:
 491  * - on platforms where sizeof(__stl_atomic_t) == sizeof(void*) atomic
 492  *   exchange can be done on pointers
 493  * - on platform without atomic operation swap is done in a critical section,
 494  *   portable but inefficient.
 495  */
 496 template <int __use_ptr_atomic_swap>
 497 class _Atomic_swap_struct {
 498 public:
 499 #if defined (_STLP_THREADS) && \
 500     !defined (_STLP_ATOMIC_EXCHANGE) && \
 501     (defined (_STLP_PTHREADS) || defined (_STLP_UITHREADS) || defined (_STLP_OS2THREADS) || \
 502      defined (_STLP_USE_PTHREAD_SPINLOCK) || defined (_STLP_NWTHREADS))
 503 #  define _STLP_USE_ATOMIC_SWAP_MUTEX
 504   static _STLP_STATIC_MUTEX _S_swap_lock;
 505 #endif
 506
 507   static __stl_atomic_t _S_swap(_STLP_VOLATILE __stl_atomic_t* __p, __stl_atomic_t __q) {
 508 #if defined (_STLP_THREADS)
 509 #  if defined (_STLP_ATOMIC_EXCHANGE)
 510   return _STLP_ATOMIC_EXCHANGE(__p, __q);
 511 #  elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)
 512   _S_swap_lock._M_acquire_lock();
 513   __stl_atomic_t __result = *__p;
 514   *__p = __q;
 515   _S_swap_lock._M_release_lock();
 516   return __result;
 517 #  else
 518 #    error Missing atomic swap implementation
 519 #  endif
 520 #else
 521   /* no threads */
 522   __stl_atomic_t __result = *__p;
 523   *__p = __q;
 524   return __result;
 525 #endif // _STLP_THREADS
 526   }
 527
 528   static void* _S_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) {
 529 #if defined (_STLP_THREADS)
 530 #  if defined (_STLP_ATOMIC_EXCHANGE_PTR)
 531   return _STLP_ATOMIC_EXCHANGE_PTR(__p, __q);
 532 #  elif defined (_STLP_ATOMIC_EXCHANGE)
 533   _STLP_STATIC_ASSERT(sizeof(__stl_atomic_t) == sizeof(void*))
 534   return __REINTERPRET_CAST(void*, _STLP_ATOMIC_EXCHANGE(__REINTERPRET_CAST(volatile __stl_atomic_t*, __p),
 535                                                          __REINTERPRET_CAST(__stl_atomic_t, __q))
 536                             );
 537 #  elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)
 538   _S_swap_lock._M_acquire_lock();
 539   void *__result = *__p;
 540   *__p = __q;
 541   _S_swap_lock._M_release_lock();
 542   return __result;
 543 #  else
 544 #    error Missing pointer atomic swap implementation
 545 #  endif
 546 #else
 547   /* no thread */
 548   void *__result = *__p;
 549   *__p = __q;
 550   return __result;
 551 #endif
 552   }
 553 };
 554
 555 _STLP_TEMPLATE_NULL
 556 class _Atomic_swap_struct<0> {
 557 public:
 558 #if defined (_STLP_THREADS) && \
 559     (!defined (_STLP_ATOMIC_EXCHANGE) || !defined (_STLP_ATOMIC_EXCHANGE_PTR)) && \
 560     (defined (_STLP_PTHREADS) || defined (_STLP_UITHREADS) || defined (_STLP_OS2THREADS) || \
 561      defined (_STLP_USE_PTHREAD_SPINLOCK) || defined (_STLP_NWTHREADS))
 562 #  define _STLP_USE_ATOMIC_SWAP_MUTEX
 563   static _STLP_STATIC_MUTEX _S_swap_lock;
 564 #endif
 565
 566   static __stl_atomic_t _S_swap(_STLP_VOLATILE __stl_atomic_t* __p, __stl_atomic_t __q) {
 567 #if defined (_STLP_THREADS)
 568 #  if defined (_STLP_ATOMIC_EXCHANGE)
 569   return _STLP_ATOMIC_EXCHANGE(__p, __q);
 570 #  elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)
 571   /* This should be portable, but performance is expected
 572    * to be quite awful.  This really needs platform specific
 573    * code.
 574    */
 575   _S_swap_lock._M_acquire_lock();
 576   __stl_atomic_t __result = *__p;
 577   *__p = __q;
 578   _S_swap_lock._M_release_lock();
 579   return __result;
 580 #  else
 581 #    error Missing atomic swap implementation
 582 #  endif
 583 #else
 584   /* no threads */
 585   __stl_atomic_t __result = *__p;
 586   *__p = __q;
 587   return __result;
 588 #endif // _STLP_THREADS
 589   }
 590
 591   static void* _S_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) {
 592 #if defined (_STLP_THREADS)
 593 #  if defined (_STLP_ATOMIC_EXCHANGE_PTR)
 594   return _STLP_ATOMIC_EXCHANGE_PTR(__p, __q);
 595 #  elif defined (_STLP_ATOMIC_EXCHANGE)
 596   _STLP_STATIC_ASSERT(sizeof(__stl_atomic_t) == sizeof(void*))
 597   return __REINTERPRET_CAST(void*, _STLP_ATOMIC_EXCHANGE(__REINTERPRET_CAST(volatile __stl_atomic_t*, __p),
 598                                                          __REINTERPRET_CAST(__stl_atomic_t, __q))
 599                             );
 600 #  elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)
 601   _S_swap_lock._M_acquire_lock();
 602   void *__result = *__p;
 603   *__p = __q;
 604   _S_swap_lock._M_release_lock();
 605   return __result;
 606 #  else
 607 #    error Missing pointer atomic swap implementation
 608 #  endif
 609 #else
 610   /* no thread */
 611   void *__result = *__p;
 612   *__p = __q;
 613   return __result;
 614 #endif
 615   }
 616 };
 617
 618 #if defined (_STLP_MSVC) && (_STLP_MSVC == 1300)
 619 #  pragma warning (push)
 620 #  pragma warning (disable : 4189) //__use_ptr_atomic_swap initialized but not used
 621 #endif
 622
 623 inline __stl_atomic_t _STLP_CALL _Atomic_swap(_STLP_VOLATILE __stl_atomic_t * __p, __stl_atomic_t __q) {
 624   const int __use_ptr_atomic_swap = sizeof(__stl_atomic_t) == sizeof(void*);
 625   return _Atomic_swap_struct<__use_ptr_atomic_swap>::_S_swap(__p, __q);
 626 }
 627
 628 inline void* _STLP_CALL _Atomic_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) {
 629   const int __use_ptr_atomic_swap = sizeof(__stl_atomic_t) == sizeof(void*);
 630   return _Atomic_swap_struct<__use_ptr_atomic_swap>::_S_swap_ptr(__p, __q);
 631 }
 632
 633 #if defined (_STLP_MSVC) && (_STLP_MSVC == 1300)
 634 #  pragma warning (pop)
 635 #endif
 636
 637 #if defined (_STLP_BETHREADS)
 638 template <int __inst>
 639 struct _STLP_beos_static_lock_data {
 640   static bool is_init;
 641   struct mutex_t : public _STLP_mutex {
 642     mutex_t()
 643     { _STLP_beos_static_lock_data<0>::is_init = true; }
 644     ~mutex_t()
 645     { _STLP_beos_static_lock_data<0>::is_init = false; }
 646   };
 647   static mutex_t mut;
 648 };
 649
 650 template <int __inst>
 651 bool _STLP_beos_static_lock_data<__inst>::is_init = false;
 652 template <int __inst>
 653 typename _STLP_beos_static_lock_data<__inst>::mutex_t _STLP_beos_static_lock_data<__inst>::mut;
 654
 655 inline void _STLP_mutex_base::_M_acquire_lock() {
 656   if (sem == 0) {
 657     // we need to initialise on demand here
 658     // to prevent race conditions use our global
 659     // mutex if it's available:
 660     if (_STLP_beos_static_lock_data<0>::is_init) {
 661       _STLP_auto_lock al(_STLP_beos_static_lock_data<0>::mut);
 662       if (sem == 0) _M_initialize();
 663     }
 664     else {
 665       // no lock available, we must still be
 666       // in startup code, THERE MUST BE ONE THREAD
 667       // ONLY active at this point.
 668       _M_initialize();
 669     }
 670   }
 671   status_t t;
 672   t = acquire_sem(sem);
 673   assert(t == B_NO_ERROR);
 674 }
 675 #endif
 676
 677 _STLP_END_NAMESPACE
 678
 679 #if !defined (_STLP_LINK_TIME_INSTANTIATION)
 680 #  include <stl/_threads.c>
 681 #endif
 682
 683 #endif /* _STLP_INTERNAL_THREADS_H */
 684
 685 // Local Variables:
 686 // mode:C++
 687 // End: