OSDN Git Service

* include/bits/stl_threads.h (_Atomic_swap): Only enable path
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / bits / stl_threads.h
1 // Threading support -*- C++ -*-
2
3 // Copyright (C) 2001 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library.  This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 2, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 // GNU General Public License for more details.
15
16 // You should have received a copy of the GNU General Public License along
17 // with this library; see the file COPYING.  If not, write to the Free
18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
19 // USA.
20
21 // As a special exception, you may use this file as part of a free software
22 // library without restriction.  Specifically, if other files instantiate
23 // templates or use macros or inline functions from this file, or you compile
24 // this file and link it with other files to produce an executable, this
25 // file does not by itself cause the resulting executable to be covered by
26 // the GNU General Public License.  This exception does not however
27 // invalidate any other reasons why the executable file might be covered by
28 // the GNU General Public License.
29
30 /*
31  * Copyright (c) 1997-1999
32  * Silicon Graphics Computer Systems, Inc.
33  *
34  * Permission to use, copy, modify, distribute and sell this software
35  * and its documentation for any purpose is hereby granted without fee,
36  * provided that the above copyright notice appear in all copies and
37  * that both that copyright notice and this permission notice appear
38  * in supporting documentation.  Silicon Graphics makes no
39  * representations about the suitability of this software for any
40  * purpose.  It is provided "as is" without express or implied warranty.
41  */
42
43 /** @file stl_threads.h
44  *  This is an internal header file, included by other library headers.
45  *  You should not attempt to use it directly.
46  */
47
48 #ifndef __SGI_STL_INTERNAL_THREADS_H
49 #define __SGI_STL_INTERNAL_THREADS_H
50
51 // Supported threading models are native SGI, pthreads, uithreads
52 // (similar to pthreads, but based on an earlier draft of the Posix
53 // threads standard), and Win32 threads.  Uithread support by Jochen
54 // Schlick, 1999.
55
56 // GCC extension begin
57 // In order to present a stable threading configuration, in all cases,
58 // gcc looks for it's own abstraction layer before all others.  All
59 // modifications to this file are marked to allow easier importation of
60 // STL upgrades.
61 #if defined(__STL_GTHREADS)
62 #include "bits/gthr.h"
63 #else
64 // GCC extension end
65 #if defined(__STL_SGI_THREADS)
66 #include <mutex.h>
67 #include <time.h>
68 #elif defined(__STL_PTHREADS)
69 #include <pthread.h>
70 #elif defined(__STL_UITHREADS)
71 #include <thread.h>
72 #include <synch.h>
73 #elif defined(__STL_WIN32THREADS)
74 #include <windows.h>
75 #endif
76 // GCC extension begin
77 #endif
78 // GCC extension end
79
80 namespace std
81 {
82
83 // Class _Refcount_Base provides a type, _RC_t, a data member,
84 // _M_ref_count, and member functions _M_incr and _M_decr, which perform
85 // atomic preincrement/predecrement.  The constructor initializes 
86 // _M_ref_count.
87
88 // Hack for SGI o32 compilers.
89 #if defined(__STL_SGI_THREADS) && !defined(__add_and_fetch) && \
90     (__mips < 3 || !(defined (_ABIN32) || defined(_ABI64)))
91 #  define __add_and_fetch(__l,__v) add_then_test((unsigned long*)__l,__v)  
92 #  define __test_and_set(__l,__v)  test_and_set(__l,__v)
93 #endif /* o32 */
94
95 struct _Refcount_Base
96 {
97   // The type _RC_t
98 # ifdef __STL_WIN32THREADS
99   typedef long _RC_t;
100 # else
101   typedef size_t _RC_t;
102 #endif
103   
104   // The data member _M_ref_count
105    volatile _RC_t _M_ref_count;
106
107   // Constructor
108 // GCC extension begin
109 #ifdef __STL_GTHREADS
110   __gthread_mutex_t _M_ref_count_lock;
111   _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
112     {
113 #ifdef __GTHREAD_MUTEX_INIT
114       __gthread_mutex_t __tmp = __GTHREAD_MUTEX_INIT;
115       _M_ref_count_lock = __tmp;
116 #elif defined(__GTHREAD_MUTEX_INIT_FUNCTION)
117       __GTHREAD_MUTEX_INIT_FUNCTION (&_M_ref_count_lock);
118 #else
119 #error __GTHREAD_MUTEX_INIT or __GTHREAD_MUTEX_INIT_FUNCTION should be defined by gthr.h abstraction layer, report problem to libstdc++@gcc.gnu.org.
120 #endif
121     }
122 #else
123 // GCC extension end
124 # ifdef __STL_PTHREADS
125   pthread_mutex_t _M_ref_count_lock;
126   _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
127     { pthread_mutex_init(&_M_ref_count_lock, 0); }
128 # elif defined(__STL_UITHREADS)
129   mutex_t         _M_ref_count_lock;
130   _Refcount_Base(_RC_t __n) : _M_ref_count(__n)
131     { mutex_init(&_M_ref_count_lock, USYNC_THREAD, 0); }
132 # else
133   _Refcount_Base(_RC_t __n) : _M_ref_count(__n) {}
134 # endif
135 // GCC extension begin
136 #endif
137 // GCC extension end
138
139 // GCC extension begin
140 #ifdef __STL_GTHREADS
141   void _M_incr() {
142     __gthread_mutex_lock(&_M_ref_count_lock);
143     ++_M_ref_count;
144     __gthread_mutex_unlock(&_M_ref_count_lock);
145   }
146   _RC_t _M_decr() {
147     __gthread_mutex_lock(&_M_ref_count_lock);
148     volatile _RC_t __tmp = --_M_ref_count;
149     __gthread_mutex_unlock(&_M_ref_count_lock);
150     return __tmp;
151   }
152 #else
153 // GCC extension end
154   // _M_incr and _M_decr
155 # ifdef __STL_SGI_THREADS
156   void _M_incr() {  __add_and_fetch(&_M_ref_count, 1); }
157   _RC_t _M_decr() { return __add_and_fetch(&_M_ref_count, (size_t) -1); }
158 # elif defined (__STL_WIN32THREADS)
159    void _M_incr() { InterlockedIncrement((_RC_t*)&_M_ref_count); }
160   _RC_t _M_decr() { return InterlockedDecrement((_RC_t*)&_M_ref_count); }
161 # elif defined(__STL_PTHREADS)
162   void _M_incr() {
163     pthread_mutex_lock(&_M_ref_count_lock);
164     ++_M_ref_count;
165     pthread_mutex_unlock(&_M_ref_count_lock);
166   }
167   _RC_t _M_decr() {
168     pthread_mutex_lock(&_M_ref_count_lock);
169     volatile _RC_t __tmp = --_M_ref_count;
170     pthread_mutex_unlock(&_M_ref_count_lock);
171     return __tmp;
172   }
173 # elif defined(__STL_UITHREADS)
174   void _M_incr() {
175     mutex_lock(&_M_ref_count_lock);
176     ++_M_ref_count;
177     mutex_unlock(&_M_ref_count_lock);
178   }
179   _RC_t _M_decr() {
180     mutex_lock(&_M_ref_count_lock);
181     /*volatile*/ _RC_t __tmp = --_M_ref_count;
182     mutex_unlock(&_M_ref_count_lock);
183     return __tmp;
184   }
185 # else  /* No threads */
186   void _M_incr() { ++_M_ref_count; }
187   _RC_t _M_decr() { return --_M_ref_count; }
188 # endif
189 // GCC extension begin
190 #endif
191 // GCC extension end
192 };
193
194 // Atomic swap on unsigned long
195 // This is guaranteed to behave as though it were atomic only if all
196 // possibly concurrent updates use _Atomic_swap.
197 // In some cases the operation is emulated with a lock.
198 // GCC extension begin
199 #if defined (__STL_GTHREADS) && defined (__GTHREAD_MUTEX_INIT)
200 // We don't provide an _Atomic_swap in this configuration.  This only
201 // affects the use of ext/rope with threads.  Someone could add this
202 // later, if required.  You can start by cloning the __STL_PTHREADS
203 // path while making the obvious changes.  Later it could be optimized
204 // to use the atomicity.h abstraction layer from libstdc++-v3.
205 // vyzo: simple _Atomic_swap implementation following the guidelines above
206        // We use a template here only to get a unique initialized instance.
207     template<int __dummy>
208     struct _Swap_lock_struct {
209         static __gthread_mutex_t _S_swap_lock;
210     };
211
212     template<int __dummy>
213     __gthread_mutex_t
214     _Swap_lock_struct<__dummy>::_S_swap_lock = __GTHREAD_MUTEX_INIT;
215
216     // This should be portable, but performance is expected
217     // to be quite awful.  This really needs platform specific
218     // code.
219     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
220         __gthread_mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
221         unsigned long __result = *__p;
222         *__p = __q;
223         __gthread_mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
224         return __result;
225     }
226
227 #else
228 // GCC extension end
229 # ifdef __STL_SGI_THREADS
230     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
231 #       if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64))
232             return test_and_set(__p, __q);
233 #       else
234             return __test_and_set(__p, (unsigned long)__q);
235 #       endif
236     }
237 # elif defined(__STL_WIN32THREADS)
238     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
239         return (unsigned long) InterlockedExchange((LPLONG)__p, (LONG)__q);
240     }
241 # elif defined(__STL_PTHREADS)
242     // We use a template here only to get a unique initialized instance.
243     template<int __dummy>
244     struct _Swap_lock_struct {
245         static pthread_mutex_t _S_swap_lock;
246     };
247
248     template<int __dummy>
249     pthread_mutex_t
250     _Swap_lock_struct<__dummy>::_S_swap_lock = PTHREAD_MUTEX_INITIALIZER;
251
252     // This should be portable, but performance is expected
253     // to be quite awful.  This really needs platform specific
254     // code.
255     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
256         pthread_mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
257         unsigned long __result = *__p;
258         *__p = __q;
259         pthread_mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
260         return __result;
261     }
262 # elif defined(__STL_UITHREADS)
263     // We use a template here only to get a unique initialized instance.
264     template<int __dummy>
265     struct _Swap_lock_struct {
266         static mutex_t _S_swap_lock;
267     };
268
269     template<int __dummy>
270     mutex_t
271     _Swap_lock_struct<__dummy>::_S_swap_lock = DEFAULTMUTEX;
272
273     // This should be portable, but performance is expected
274     // to be quite awful.  This really needs platform specific
275     // code.
276     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
277         mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
278         unsigned long __result = *__p;
279         *__p = __q;
280         mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
281         return __result;
282     }
283 # elif defined (__STL_SOLARIS_THREADS)
284     // any better solutions ?
285     // We use a template here only to get a unique initialized instance.
286     template<int __dummy>
287     struct _Swap_lock_struct {
288         static mutex_t _S_swap_lock;
289     };
290
291 # if ( __STL_STATIC_TEMPLATE_DATA > 0 )
292     template<int __dummy>
293     mutex_t
294     _Swap_lock_struct<__dummy>::_S_swap_lock = DEFAULTMUTEX;
295 #  else
296     __DECLARE_INSTANCE(mutex_t, _Swap_lock_struct<__dummy>::_S_swap_lock, 
297                        =DEFAULTMUTEX);
298 # endif /* ( __STL_STATIC_TEMPLATE_DATA > 0 ) */
299
300     // This should be portable, but performance is expected
301     // to be quite awful.  This really needs platform specific
302     // code.
303     inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
304         mutex_lock(&_Swap_lock_struct<0>::_S_swap_lock);
305         unsigned long __result = *__p;
306         *__p = __q;
307         mutex_unlock(&_Swap_lock_struct<0>::_S_swap_lock);
308         return __result;
309     }
310 # else
311     static inline unsigned long _Atomic_swap(unsigned long * __p, unsigned long __q) {
312         unsigned long __result = *__p;
313         *__p = __q;
314         return __result;
315     }
316 # endif
317 // GCC extension begin
318 #endif
319 // GCC extension end
320
321 // Locking class.  Note that this class *does not have a constructor*.
322 // It must be initialized either statically, with __STL_MUTEX_INITIALIZER,
323 // or dynamically, by explicitly calling the _M_initialize member function.
324 // (This is similar to the ways that a pthreads mutex can be initialized.)
325 // There are explicit member functions for acquiring and releasing the lock.
326
327 // There is no constructor because static initialization is essential for
328 // some uses, and only a class aggregate (see section 8.5.1 of the C++
329 // standard) can be initialized that way.  That means we must have no
330 // constructors, no base classes, no virtual functions, and no private or
331 // protected members.
332
333 // Helper struct.  This is a workaround for various compilers that don't
334 // handle static variables in inline functions properly.
335 template <int __inst>
336 struct _STL_mutex_spin {
337   enum { __low_max = 30, __high_max = 1000 };
338   // Low if we suspect uniprocessor, high for multiprocessor.
339
340   static unsigned __max;
341   static unsigned __last;
342 };
343
344 template <int __inst>
345 unsigned _STL_mutex_spin<__inst>::__max = _STL_mutex_spin<__inst>::__low_max;
346
347 template <int __inst>
348 unsigned _STL_mutex_spin<__inst>::__last = 0;
349
350 // GCC extension begin
351 #if defined(__STL_GTHREADS)
352 #if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION)
353 extern __gthread_mutex_t _GLIBCPP_mutex;
354 extern __gthread_mutex_t *_GLIBCPP_mutex_address;
355 extern __gthread_once_t _GLIBCPP_once;
356 extern void _GLIBCPP_mutex_init (void);
357 extern void _GLIBCPP_mutex_address_init (void);
358 #endif
359 #endif
360 // GCC extension end
361
362 struct _STL_mutex_lock
363 {
364 // GCC extension begin
365 #if defined(__STL_GTHREADS)
366   // The class must be statically initialized with __STL_MUTEX_INITIALIZER.
367 #if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION)
368   volatile int _M_init_flag;
369   __gthread_once_t _M_once;
370 #endif
371   __gthread_mutex_t _M_lock;
372   void _M_initialize() {
373 #ifdef __GTHREAD_MUTEX_INIT
374     // There should be no code in this path given the usage rules above.
375 #elif defined(__GTHREAD_MUTEX_INIT_FUNCTION)
376     if (_M_init_flag) return;
377     if (__gthread_once (&_GLIBCPP_once, _GLIBCPP_mutex_init) != 0
378         && __gthread_active_p ())
379       abort ();
380     __gthread_mutex_lock (&_GLIBCPP_mutex);
381     if (!_M_init_flag) {
382         // Even though we have a global lock, we use __gthread_once to be
383         // absolutely certain the _M_lock mutex is only initialized once on
384         // multiprocessor systems.
385         _GLIBCPP_mutex_address = &_M_lock;
386         if (__gthread_once (&_M_once, _GLIBCPP_mutex_address_init) != 0
387             && __gthread_active_p ())
388           abort ();
389         _M_init_flag = 1;
390     }
391     __gthread_mutex_unlock (&_GLIBCPP_mutex);
392 #endif
393   }
394   void _M_acquire_lock() {
395 #if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION)
396     if (!_M_init_flag) _M_initialize();
397 #endif
398     __gthread_mutex_lock(&_M_lock);
399   }
400   void _M_release_lock() {
401 #if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION)
402     if (!_M_init_flag) _M_initialize();
403 #endif
404     __gthread_mutex_unlock(&_M_lock);
405   }
406 #else
407 // GCC extension end
408 #if defined(__STL_SGI_THREADS) || defined(__STL_WIN32THREADS)
409   // It should be relatively easy to get this to work on any modern Unix.
410   volatile unsigned long _M_lock;
411   void _M_initialize() { _M_lock = 0; }
412   static void _S_nsec_sleep(int __log_nsec) {
413 #     ifdef __STL_SGI_THREADS
414           struct timespec __ts;
415           /* Max sleep is 2**27nsec ~ 60msec      */
416           __ts.tv_sec = 0;
417           __ts.tv_nsec = 1L << __log_nsec;
418           nanosleep(&__ts, 0);
419 #     elif defined(__STL_WIN32THREADS)
420           if (__log_nsec <= 20) {
421               Sleep(0);
422           } else {
423               Sleep(1 << (__log_nsec - 20));
424           }
425 #     else
426 #       error unimplemented
427 #     endif
428   }
429   void _M_acquire_lock() {
430     volatile unsigned long* __lock = &this->_M_lock;
431
432     if (!_Atomic_swap((unsigned long*)__lock, 1)) {
433       return;
434     }
435     unsigned __my_spin_max = _STL_mutex_spin<0>::__max;
436     unsigned __my_last_spins = _STL_mutex_spin<0>::__last;
437     volatile unsigned __junk = 17;      // Value doesn't matter.
438     unsigned __i;
439     for (__i = 0; __i < __my_spin_max; __i++) {
440       if (__i < __my_last_spins/2 || *__lock) {
441         __junk *= __junk; __junk *= __junk;
442         __junk *= __junk; __junk *= __junk;
443         continue;
444       }
445       if (!_Atomic_swap((unsigned long*)__lock, 1)) {
446         // got it!
447         // Spinning worked.  Thus we're probably not being scheduled
448         // against the other process with which we were contending.
449         // Thus it makes sense to spin longer the next time.
450         _STL_mutex_spin<0>::__last = __i;
451         _STL_mutex_spin<0>::__max = _STL_mutex_spin<0>::__high_max;
452         return;
453       }
454     }
455     // We are probably being scheduled against the other process.  Sleep.
456     _STL_mutex_spin<0>::__max = _STL_mutex_spin<0>::__low_max;
457     for (__i = 0 ;; ++__i) {
458       int __log_nsec = __i + 6;
459
460       if (__log_nsec > 27) __log_nsec = 27;
461       if (!_Atomic_swap((unsigned long *)__lock, 1)) {
462         return;
463       }
464       _S_nsec_sleep(__log_nsec);
465     }
466   }
467   void _M_release_lock() {
468     volatile unsigned long* __lock = &_M_lock;
469 #   if defined(__STL_SGI_THREADS) && defined(__GNUC__) && __mips >= 3
470         asm("sync");
471         *__lock = 0;
472 #   elif defined(__STL_SGI_THREADS) && __mips >= 3 \
473          && (defined (_ABIN32) || defined(_ABI64))
474         __lock_release(__lock);
475 #   else 
476         *__lock = 0;
477         // This is not sufficient on many multiprocessors, since
478         // writes to protected variables and the lock may be reordered.
479 #   endif
480   }
481
482 // We no longer use win32 critical sections.
483 // They appear to be slower in the contention-free case,
484 // and they appear difficult to initialize without introducing a race.
485
486 #elif defined(__STL_PTHREADS)
487   pthread_mutex_t _M_lock;
488   void _M_initialize()   { pthread_mutex_init(&_M_lock, NULL); }
489   void _M_acquire_lock() { pthread_mutex_lock(&_M_lock); }
490   void _M_release_lock() { pthread_mutex_unlock(&_M_lock); }
491 #elif defined(__STL_UITHREADS)
492   mutex_t _M_lock;
493   void _M_initialize()   { mutex_init(&_M_lock, USYNC_THREAD, 0); }
494   void _M_acquire_lock() { mutex_lock(&_M_lock); }
495   void _M_release_lock() { mutex_unlock(&_M_lock); }
496 #else /* No threads */
497   void _M_initialize()   {}
498   void _M_acquire_lock() {}
499   void _M_release_lock() {}
500 #endif
501 // GCC extension begin
502 #endif
503 // GCC extension end
504 };
505
506 // GCC extension begin
507 #if defined(__STL_GTHREADS)
508 #ifdef __GTHREAD_MUTEX_INIT
509 #define __STL_MUTEX_INITIALIZER = { __GTHREAD_MUTEX_INIT }
510 #elif defined(__GTHREAD_MUTEX_INIT_FUNCTION)
511 #ifdef __GTHREAD_MUTEX_INIT_DEFAULT
512 #define __STL_MUTEX_INITIALIZER \
513   = { 0, __GTHREAD_ONCE_INIT, __GTHREAD_MUTEX_INIT_DEFAULT }
514 #else
515 #define __STL_MUTEX_INITIALIZER = { 0, __GTHREAD_ONCE_INIT }
516 #endif
517 #endif
518 #else
519 // GCC extension end
520 #ifdef __STL_PTHREADS
521 // Pthreads locks must be statically initialized to something other than
522 // the default value of zero.
523 #   define __STL_MUTEX_INITIALIZER = { PTHREAD_MUTEX_INITIALIZER }
524 #elif defined(__STL_UITHREADS)
525 // UIthreads locks must be statically initialized to something other than
526 // the default value of zero.
527 #   define __STL_MUTEX_INITIALIZER = { DEFAULTMUTEX }
528 #elif defined(__STL_SGI_THREADS) || defined(__STL_WIN32THREADS)
529 #   define __STL_MUTEX_INITIALIZER = { 0 }
530 #else
531 #   define __STL_MUTEX_INITIALIZER
532 #endif
533 // GCC extension begin
534 #endif
535 // GCC extension end
536
537
538 // A locking class that uses _STL_mutex_lock.  The constructor takes a
539 // reference to an _STL_mutex_lock, and acquires a lock.  The
540 // destructor releases the lock.  It's not clear that this is exactly
541 // the right functionality.  It will probably change in the future.
542
543 struct _STL_auto_lock
544 {
545   _STL_mutex_lock& _M_lock;
546   
547   _STL_auto_lock(_STL_mutex_lock& __lock) : _M_lock(__lock)
548     { _M_lock._M_acquire_lock(); }
549   ~_STL_auto_lock() { _M_lock._M_release_lock(); }
550
551 private:
552   void operator=(const _STL_auto_lock&);
553   _STL_auto_lock(const _STL_auto_lock&);
554 };
555
556 } // namespace std
557
558 #endif /* __SGI_STL_INTERNAL_THREADS_H */
559
560 // Local Variables:
561 // mode:C++
562 // End:
563