stl_thre.h
上传用户:nizebo
上传日期:2022-05-14
资源大小:882k
文件大小:12k
源码类别:

STL

开发平台:

Visual C++

  1. /*
  2.  * Copyright (c) 1997-1999
  3.  * Silicon Graphics Computer Systems, Inc.
  4.  *
  5.  * Permission to use, copy, modify, distribute and sell this software
  6.  * and its documentation for any purpose is hereby granted without fee,
  7.  * provided that the above copyright notice appear in all copies and
  8.  * that both that copyright notice and this permission notice appear
  9.  * in supporting documentation.  Silicon Graphics makes no
  10.  * representations about the suitability of this software for any
  11.  * purpose.  It is provided "as is" without express or implied warranty.
  12.  */
  13. // WARNING: This is an internal header file, included by other C++
  14. // standard library headers.  You should not attempt to use this header
  15. // file directly.
  16. // Stl_config.h should be included before this file.
  17. #ifndef __SGI_STL_INTERNAL_THREADS_H
  18. #define __SGI_STL_INTERNAL_THREADS_H
  19. // Supported threading models are native SGI, pthreads, uithreads
  20. // (similar to pthreads, but based on an earlier draft of the Posix
  21. // threads standard), and Win32 threads.  Uithread support by Jochen
  22. // Schlick, 1999.
  23. #if defined(__STL_SGI_THREADS)
  24. #include <mutex.h>
  25. #include <time.h>
  26. #elif defined(__STL_PTHREADS)
  27. #include <pthread.h>
  28. #elif defined(__STL_UITHREADS)
  29. #include <thread.h>
  30. #include <synch.h>
  31. #elif defined(__STL_WIN32THREADS)
  32. #include <windows.h>
  33. #endif
  34. __STL_BEGIN_NAMESPACE
  35. // Class _Refcount_Base provides a type, _RC_t, a data member,
  36. // _M_ref_count, and member functions _M_incr and _M_decr, which perform
  37. // atomic preincrement/predecrement.  The constructor initializes 
  38. // _M_ref_count.
  39. // Hack for SGI o32 compilers.
  40. #if defined(__STL_SGI_THREADS) && !defined(__add_and_fetch) && 
  41.     (__mips < 3 || !(defined (_ABIN32) || defined(_ABI64)))
  42. #  define __add_and_fetch(__l,__v) add_then_test((unsigned long*)__l,__v)  
  43. #  define __test_and_set(__l,__v)  test_and_set(__l,__v)
  44. #endif /* o32 */
  45. struct _Refcount_Base
  46. {
  47.   // The type _RC_t
  48. # ifdef __STL_WIN32THREADS
  49.   typedef long _RC_t;
  50. # else
  51.   typedef size_t _RC_t;
  52. #endif
  53.   
  54.   // The data member _M_ref_count
  55.    volatile _RC_t _M_ref_count;
  56.   // Constructor
  57. # ifdef __STL_PTHREADS
  58.   pthread_mutex_t _M_ref_count_lock;
  59.   _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
  60.     { pthread_mutex_init(&_M_ref_count_lock, 0); }
  61. # elif defined(__STL_UITHREADS)
  62.   mutex_t         _M_ref_count_lock;
  63.   _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
  64.     { mutex_init(&_M_ref_count_lock, USYNC_THREAD, 0); }
  65. # else
  66.   _Refcount_Base(_RC_t __n) : _M_ref_count(__n) {}
  67. # endif
  68.   // _M_incr and _M_decr
  69. # ifdef __STL_SGI_THREADS
  70.   void _M_incr() {  __add_and_fetch(&_M_ref_count, 1); }
  71.   _RC_t _M_decr() { return __add_and_fetch(&_M_ref_count, (size_t) -1); }
  72. # elif defined (__STL_WIN32THREADS)
  73.    void _M_incr() { InterlockedIncrement((_RC_t*)&_M_ref_count); }
  74.   _RC_t _M_decr() { return InterlockedDecrement((_RC_t*)&_M_ref_count); }
  75. # elif defined(__STL_PTHREADS)
  76.   void _M_incr() {
  77.     pthread_mutex_lock(&_M_ref_count_lock);
  78.     ++_M_ref_count;
  79.     pthread_mutex_unlock(&_M_ref_count_lock);
  80.   }
  81.   _RC_t _M_decr() {
  82.     pthread_mutex_lock(&_M_ref_count_lock);
  83.     volatile _RC_t __tmp = --_M_ref_count;
  84.     pthread_mutex_unlock(&_M_ref_count_lock);
  85.     return __tmp;
  86.   }
  87. # elif defined(__STL_UITHREADS)
  88.   void _M_incr() {
  89.     mutex_lock(&_M_ref_count_lock);
  90.     ++_M_ref_count;
  91.     mutex_unlock(&_M_ref_count_lock);
  92.   }
  93.   _RC_t _M_decr() {
  94.     mutex_lock(&_M_ref_count_lock);
  95.     /*volatile*/ _RC_t __tmp = --_M_ref_count;
  96.     mutex_unlock(&_M_ref_count_lock);
  97.     return __tmp;
  98.   }
  99. # else  /* No threads */
  100.   void _M_incr() { ++_M_ref_count; }
  101.   _RC_t _M_decr() { return --_M_ref_count; }
  102. # endif
  103. };
  104. // Atomic swap on unsigned long
  105. // This is guaranteed to behave as though it were atomic only if all
  106. // possibly concurrent updates use _Atomic_swap.
  107. // In some cases the operation is emulated with a lock.
  108. # ifdef __STL_SGI_THREADS
  109.     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
  110. #       if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64))
  111.             return test_and_set(__p, __q);
  112. #       else
  113.             return __test_and_set(__p, (unsigned long)__q);
  114. #       endif
  115.     }
  116. # elif defined(__STL_WIN32THREADS)
  117.     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
  118.         return (unsigned long) InterlockedExchange((LPLONG)__p, (LONG)__q);
  119.     }
  120. # elif defined(__STL_PTHREADS)
  121.     // We use a template here only to get a unique initialized instance.
  122.     template<int __dummy>
  123.     struct _Swap_lock_struct {
  124.         static pthread_mutex_t _S_swap_lock;
  125.     };
  126.     template<int __dummy>
  127.     pthread_mutex_t
  128.     _Swap_lock_struct<__dummy>::_S_swap_lock = PTHREAD_MUTEX_INITIALIZER;
  129.     // This should be portable, but performance is expected
  130.     // to be quite awful.  This really needs platform specific
  131.     // code.
  132.     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
  133.         pthread_mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
  134.         unsigned long __result = *__p;
  135.         *__p = __q;
  136.         pthread_mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
  137.         return __result;
  138.     }
  139. # elif defined(__STL_UITHREADS)
  140.     // We use a template here only to get a unique initialized instance.
  141.     template<int __dummy>
  142.     struct _Swap_lock_struct {
  143.         static mutex_t _S_swap_lock;
  144.     };
  145.     template<int __dummy>
  146.     mutex_t
  147.     _Swap_lock_struct<__dummy>::_S_swap_lock = DEFAULTMUTEX;
  148.     // This should be portable, but performance is expected
  149.     // to be quite awful.  This really needs platform specific
  150.     // code.
  151.     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
  152.         mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
  153.         unsigned long __result = *__p;
  154.         *__p = __q;
  155.         mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
  156.         return __result;
  157.     }
  158. # elif defined (__STL_SOLARIS_THREADS)
  159.     // any better solutions ?
  160.     // We use a template here only to get a unique initialized instance.
  161.     template<int __dummy>
  162.     struct _Swap_lock_struct {
  163.         static mutex_t _S_swap_lock;
  164.     };
  165. # if ( __STL_STATIC_TEMPLATE_DATA > 0 )
  166.     template<int __dummy>
  167.     mutex_t
  168.     _Swap_lock_struct<__dummy>::_S_swap_lock = DEFAULTMUTEX;
  169. #  else
  170.     __DECLARE_INSTANCE(mutex_t, _Swap_lock_struct<__dummy>::_S_swap_lock, 
  171.                        =DEFAULTMUTEX);
  172. # endif /* ( __STL_STATIC_TEMPLATE_DATA > 0 ) */
  173.     // This should be portable, but performance is expected
  174.     // to be quite awful.  This really needs platform specific
  175.     // code.
  176.     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
  177.         mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
  178.         unsigned long __result = *__p;
  179.         *__p = __q;
  180.         mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
  181.         return __result;
  182.     }
  183. # else
  184.     static inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
  185.         unsigned long __result = *__p;
  186.         *__p = __q;
  187.         return __result;
  188.     }
  189. # endif
  190. // Locking class.  Note that this class *does not have a constructor*.
  191. // It must be initialized either statically, with __STL_MUTEX_INITIALIZER,
  192. // or dynamically, by explicitly calling the _M_initialize member function.
  193. // (This is similar to the ways that a pthreads mutex can be initialized.)
  194. // There are explicit member functions for acquiring and releasing the lock.
  195. // There is no constructor because static initialization is essential for
  196. // some uses, and only a class aggregate (see section 8.5.1 of the C++
  197. // standard) can be initialized that way.  That means we must have no
  198. // constructors, no base classes, no virtual functions, and no private or
  199. // protected members.
  200. // Helper struct.  This is a workaround for various compilers that don't
  201. // handle static variables in inline functions properly.
  202. template <int __inst>
  203. struct _STL_mutex_spin {
  204.   enum { __low_max = 30, __high_max = 1000 };
  205.   // Low if we suspect uniprocessor, high for multiprocessor.
  206.   static unsigned __max;
  207.   static unsigned __last;
  208. };
  209. template <int __inst>
  210. unsigned _STL_mutex_spin<__inst>::__max = _STL_mutex_spin<__inst>::__low_max;
  211. template <int __inst>
  212. unsigned _STL_mutex_spin<__inst>::__last = 0;
  213. struct _STL_mutex_lock
  214. {
  215. #if defined(__STL_SGI_THREADS) || defined(__STL_WIN32THREADS)
  216.   // It should be relatively easy to get this to work on any modern Unix.
  217.   volatile unsigned long _M_lock;
  218.   void _M_initialize() { _M_lock = 0; }
  219.   static void _S_nsec_sleep(int __log_nsec) {
  220. #     ifdef __STL_SGI_THREADS
  221.           struct timespec __ts;
  222.           /* Max sleep is 2**27nsec ~ 60msec      */
  223.           __ts.tv_sec = 0;
  224.           __ts.tv_nsec = 1 << __log_nsec;
  225.           nanosleep(&__ts, 0);
  226. #     elif defined(__STL_WIN32THREADS)
  227.           if (__log_nsec <= 20) {
  228.               Sleep(0);
  229.           } else {
  230.               Sleep(1 << (__log_nsec - 20));
  231.           }
  232. #     else
  233. #       error unimplemented
  234. #     endif
  235.   }
  236.   void _M_acquire_lock() {
  237.     volatile unsigned long* __lock = &this->_M_lock;
  238.     if (!_Atomic_swap((unsigned long*)__lock, 1)) {
  239.       return;
  240.     }
  241.     unsigned __my_spin_max = _STL_mutex_spin<0>::__max;
  242.     unsigned __my_last_spins = _STL_mutex_spin<0>::__last;
  243.     volatile unsigned __junk = 17;      // Value doesn't matter.
  244.     unsigned __i;
  245.     for (__i = 0; __i < __my_spin_max; __i++) {
  246.       if (__i < __my_last_spins/2 || *__lock) {
  247.         __junk *= __junk; __junk *= __junk;
  248.         __junk *= __junk; __junk *= __junk;
  249.         continue;
  250.       }
  251.       if (!_Atomic_swap((unsigned long*)__lock, 1)) {
  252.         // got it!
  253.         // Spinning worked.  Thus we're probably not being scheduled
  254.         // against the other process with which we were contending.
  255.         // Thus it makes sense to spin longer the next time.
  256.         _STL_mutex_spin<0>::__last = __i;
  257.         _STL_mutex_spin<0>::__max = _STL_mutex_spin<0>::__high_max;
  258.         return;
  259.       }
  260.     }
  261.     // We are probably being scheduled against the other process.  Sleep.
  262.     _STL_mutex_spin<0>::__max = _STL_mutex_spin<0>::__low_max;
  263.     for (__i = 0 ;; ++__i) {
  264.       int __log_nsec = __i + 6;
  265.       if (__log_nsec > 27) __log_nsec = 27;
  266.       if (!_Atomic_swap((unsigned long *)__lock, 1)) {
  267.         return;
  268.       }
  269.       _S_nsec_sleep(__log_nsec);
  270.     }
  271.   }
  272.   void _M_release_lock() {
  273.     volatile unsigned long* __lock = &_M_lock;
  274. #   if defined(__STL_SGI_THREADS) && defined(__GNUC__) && __mips >= 3
  275.         asm("sync");
  276.         *__lock = 0;
  277. #   elif defined(__STL_SGI_THREADS) && __mips >= 3 
  278.          && (defined (_ABIN32) || defined(_ABI64))
  279.         __lock_release(__lock);
  280. #   else 
  281.         *__lock = 0;
  282.         // This is not sufficient on many multiprocessors, since
  283.         // writes to protected variables and the lock may be reordered.
  284. #   endif
  285.   }
  286. // We no longer use win32 critical sections.
  287. // They appear to be slower in the contention-free case,
  288. // and they appear difficult to initialize without introducing a race.
  289. #elif defined(__STL_PTHREADS)
  290.   pthread_mutex_t _M_lock;
  291.   void _M_initialize()   { pthread_mutex_init(&_M_lock, NULL); }
  292.   void _M_acquire_lock() { pthread_mutex_lock(&_M_lock); }
  293.   void _M_release_lock() { pthread_mutex_unlock(&_M_lock); }
  294. #elif defined(__STL_UITHREADS)
  295.   mutex_t _M_lock;
  296.   void _M_initialize()   { mutex_init(&_M_lock, USYNC_THREAD, 0); }
  297.   void _M_acquire_lock() { mutex_lock(&_M_lock); }
  298.   void _M_release_lock() { mutex_unlock(&_M_lock); }
  299. #else /* No threads */
  300.   void _M_initialize()   {}
  301.   void _M_acquire_lock() {}
  302.   void _M_release_lock() {}
  303. #endif
  304. };
  305. #ifdef __STL_PTHREADS
  306. // Pthreads locks must be statically initialized to something other than
  307. // the default value of zero.
  308. #   define __STL_MUTEX_INITIALIZER = { PTHREAD_MUTEX_INITIALIZER }
  309. #elif defined(__STL_UITHREADS)
  310. // UIthreads locks must be statically initialized to something other than
  311. // the default value of zero.
  312. #   define __STL_MUTEX_INITIALIZER = { DEFAULTMUTEX }
  313. #elif defined(__STL_SGI_THREADS) || defined(__STL_WIN32THREADS)
  314. #   define __STL_MUTEX_INITIALIZER = { 0 }
  315. #else
  316. #   define __STL_MUTEX_INITIALIZER
  317. #endif
  318. // A locking class that uses _STL_mutex_lock.  The constructor takes a
  319. // reference to an _STL_mutex_lock, and acquires a lock.  The
  320. // destructor releases the lock.  It's not clear that this is exactly
  321. // the right functionality.  It will probably change in the future.
  322. struct _STL_auto_lock
  323. {
  324.   _STL_mutex_lock& _M_lock;
  325.   
  326.   _STL_auto_lock(_STL_mutex_lock& __lock) : _M_lock(__lock)
  327.     { _M_lock._M_acquire_lock(); }
  328.   ~_STL_auto_lock() { _M_lock._M_release_lock(); }
  329. private:
  330.   void operator=(const _STL_auto_lock&);
  331.   _STL_auto_lock(const _STL_auto_lock&);
  332. };
  333. __STL_END_NAMESPACE
  334. #endif /* __SGI_STL_INTERNAL_THREADS_H */
  335. // Local Variables:
  336. // mode:C++
  337. // End: