OSDN Git Service

2008-10-22 Chris Fairles <cfairles@gcc.gnu.org>
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / std / mutex
1 // <mutex> -*- C++ -*-
2
3 // Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
4 // Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library.  This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 2, or (at your option)
10 // any later version.
11
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 // GNU General Public License for more details.
16
17 // You should have received a copy of the GNU General Public License
18 // along with this library; see the file COPYING.  If not, write to
19 // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 // Boston, MA 02110-1301, USA.
21
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction.  Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License.  This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
30
31 /** @file mutex
32  *  This is a Standard C++ Library header.
33  */
34
35 #ifndef _GLIBCXX_MUTEX
36 #define _GLIBCXX_MUTEX 1
37
38 #pragma GCC system_header
39
40 #ifndef __GXX_EXPERIMENTAL_CXX0X__
41 # include <c++0x_warning.h>
42 #else
43
44 #include <tuple>
45 #include <cstddef>
46 #include <chrono>
47 #include <exception>
48 #include <type_traits>
49 #include <functional>
50 #include <system_error>
51 #include <bits/functexcept.h>
52 #include <bits/gthr.h>
53 #include <bits/move.h> // for std::swap
54
55 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
56
57 namespace std
58 {
59   /// mutex
60   class mutex
61   {
62   public:
63     typedef __gthread_mutex_t* native_handle_type;
64
65     mutex()
66     {
67       // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
68 #ifdef __GTHREAD_MUTEX_INIT
69       __gthread_mutex_t __tmp = __GTHREAD_MUTEX_INIT;
70       _M_mutex = __tmp;
71 #else
72       __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
73 #endif
74     }
75
76     mutex(const mutex&) = delete;
77     mutex& operator=(const mutex&) = delete;
78
79     void
80     lock()
81     {
82       int __e = __gthread_mutex_lock(&_M_mutex);
83
84       // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
85       if (__e)
86         __throw_system_error(__e);
87     }
88
89     bool
90     try_lock()
91     {
92       // XXX EINVAL, EAGAIN, EBUSY
93       return !__gthread_mutex_trylock(&_M_mutex);
94     }
95
96     void
97     unlock()
98     {
99       // XXX EINVAL, EAGAIN, EPERM
100       __gthread_mutex_unlock(&_M_mutex);
101     }
102
103     native_handle_type
104     native_handle()
105     { return &_M_mutex; }
106
107   private:
108     __gthread_mutex_t _M_mutex;
109   };
110
111   /// recursive_mutex
112   class recursive_mutex
113   {
114   public:
115     typedef __gthread_recursive_mutex_t* native_handle_type;
116
117     recursive_mutex()
118     {
119       // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
120 #ifdef __GTHREAD_RECURSIVE_MUTEX_INIT
121       __gthread_recursive_mutex_t __tmp = __GTHREAD_RECURSIVE_MUTEX_INIT;
122       _M_mutex = __tmp;
123 #else
124       __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);
125 #endif
126     }
127
128     recursive_mutex(const recursive_mutex&) = delete;
129     recursive_mutex& operator=(const recursive_mutex&) = delete;
130
131     void
132     lock()
133     {
134       int __e = __gthread_recursive_mutex_lock(&_M_mutex);
135
136       // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
137       if (__e)
138         __throw_system_error(__e);
139     }
140
141     bool
142     try_lock()
143     {
144       // XXX EINVAL, EAGAIN, EBUSY
145       return !__gthread_recursive_mutex_trylock(&_M_mutex);
146     }
147
148     void
149     unlock()
150     {
151       // XXX EINVAL, EAGAIN, EBUSY
152       __gthread_recursive_mutex_unlock(&_M_mutex);
153     }
154
155     native_handle_type
156     native_handle()
157     { return &_M_mutex; }
158
159   private:
160     __gthread_recursive_mutex_t  _M_mutex;
161   };
162
163   /// timed_mutex
164   class timed_mutex
165   {  
166   public:
167     typedef __gthread_mutex_t* native_handle_type;
168
169     timed_mutex()
170     {
171 #ifdef __GTHREAD_MUTEX_INIT
172       __gthread_mutex_t __tmp = __GTHREAD_MUTEX_INIT;
173       _M_mutex = __tmp;
174 #else
175       __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
176 #endif
177     }
178
179     timed_mutex(const timed_mutex&) = delete;
180     timed_mutex& operator=(const timed_mutex&) = delete;
181
182     void
183     lock()
184     {
185       int __e = __gthread_mutex_lock(&_M_mutex);
186
187       // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
188       if (__e)
189         __throw_system_error(__e);
190     }
191
192     bool
193     try_lock()
194     {
195       // XXX EINVAL, EAGAIN, EBUSY
196       return !__gthread_mutex_trylock(&_M_mutex);
197     }
198
199     template <class _Rep, class _Period>
200       bool
201       try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
202       { return __try_lock_for_impl(__rtime); }
203
204     template <class _Clock, class _Duration>
205       bool
206       try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
207       { 
208         chrono::time_point<_Clock, chrono::seconds> __s =
209           chrono::time_point_cast<chrono::seconds>(__atime);
210
211         chrono::nanoseconds __ns =
212           chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
213
214         __gthread_time_t __ts = {
215           static_cast<std::time_t>(__s.time_since_epoch().count()),
216           static_cast<long>(__ns.count())
217         };
218
219         return !__gthread_mutex_timedlock(&_M_mutex, &__ts);    
220       }
221
222     void
223     unlock()
224     {
225       // XXX EINVAL, EAGAIN, EBUSY
226       __gthread_mutex_unlock(&_M_mutex);
227     }
228
229     native_handle_type
230     native_handle()
231     { return &_M_mutex; }
232     
233   private:
234     __gthread_mutex_t _M_mutex;
235     
236 #ifdef _GLIBCXX_USE_CLOCK_MONOTONIC
237     typedef chrono::monotonic_clock __clock_t;
238 #else
239     typedef chrono::high_resolution_clock __clock_t;
240 #endif
241
242     template<typename _Rep, typename _Period>
243       typename enable_if<
244         ratio_less_equal<__clock_t::period, _Period>::value, bool>::type
245       __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime)
246       {
247         __clock_t::time_point __atime = __clock_t::now()
248           + chrono::duration_cast<__clock_t::duration>(__rtime);
249
250         return try_lock_until(__atime);
251       }
252
253     template <typename _Rep, typename _Period>
254       typename enable_if<
255         !ratio_less_equal<__clock_t::period, _Period>::value, bool>::type
256       __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime)
257       {
258         __clock_t::time_point __atime = __clock_t::now()
259           + ++chrono::duration_cast<__clock_t::duration>(__rtime);
260
261         return try_lock_until(__atime);
262       }
263   };
264
265   /// recursive_timed_mutex
266   class recursive_timed_mutex
267   {
268   public:
269     typedef __gthread_recursive_mutex_t* native_handle_type;
270
271     recursive_timed_mutex()
272     {
273       // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
274 #ifdef __GTHREAD_RECURSIVE_MUTEX_INIT
275       __gthread_recursive_mutex_t __tmp = __GTHREAD_RECURSIVE_MUTEX_INIT;
276       _M_mutex = __tmp;
277 #else
278       __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);
279 #endif
280     }
281
282     recursive_timed_mutex(const recursive_timed_mutex&) = delete;
283     recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
284
285     void
286     lock()
287     {
288       int __e = __gthread_recursive_mutex_lock(&_M_mutex);
289
290       // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
291       if (__e)
292         __throw_system_error(__e);
293     }
294
295     bool
296     try_lock()
297     {
298       // XXX EINVAL, EAGAIN, EBUSY
299       return !__gthread_recursive_mutex_trylock(&_M_mutex);
300     }
301
302     template <class _Rep, class _Period>
303       bool
304       try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
305       { return __try_lock_for_impl(__rtime); }
306
307     template <class _Clock, class _Duration>
308       bool
309       try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
310       { 
311         chrono::time_point<_Clock, chrono::seconds>  __s =
312           chrono::time_point_cast<chrono::seconds>(__atime);
313
314         chrono::nanoseconds __ns =
315           chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
316
317         __gthread_time_t __ts = {
318           static_cast<std::time_t>(__s.time_since_epoch().count()),
319           static_cast<long>(__ns.count())
320         };
321
322         return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts);
323       }
324
325     void
326     unlock()
327     {
328       // XXX EINVAL, EAGAIN, EBUSY
329       __gthread_recursive_mutex_unlock(&_M_mutex);
330     }
331
332     native_handle_type
333     native_handle()
334     { return &_M_mutex; }
335
336   private:
337     __gthread_recursive_mutex_t _M_mutex;
338
339 #ifdef _GLIBCXX_USE_CLOCK_MONOTONIC
340     typedef chrono::monotonic_clock __clock_t;
341 #else
342     typedef chrono::high_resolution_clock __clock_t;
343 #endif
344
345     template<typename _Rep, typename _Period>
346       typename enable_if<
347         ratio_less_equal<__clock_t::period, _Period>::value, bool>::type
348       __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime)
349       {
350         __clock_t::time_point __atime = __clock_t::now()
351           + chrono::duration_cast<__clock_t::duration>(__rtime);
352
353         return try_lock_until(__atime);
354       }
355
356     template <typename _Rep, typename _Period>
357       typename enable_if<
358         !ratio_less_equal<__clock_t::period, _Period>::value, bool>::type
359       __try_lock_for_impl(const chrono::duration<_Rep, _Period>& __rtime)
360       {
361         __clock_t::time_point __atime = __clock_t::now()
362           + ++chrono::duration_cast<__clock_t::duration>(__rtime);
363
364         return try_lock_until(__atime);
365       }
366   };
367
368   /// Do not acquire ownership of the mutex.
369   struct defer_lock_t { };
370
371   /// Try to acquire ownership of the mutex without blocking.
372   struct try_to_lock_t { };
373
374   /// Assume the calling thread has already obtained mutex ownership
375   /// and manage it.
376   struct adopt_lock_t { };
377
378   extern const defer_lock_t     defer_lock;
379   extern const try_to_lock_t    try_to_lock;
380   extern const adopt_lock_t     adopt_lock;
381
382   /// Thrown to indicate errors with lock operations.
383   class lock_error : public exception
384   {
385   public:
386     virtual const char*
387     what() const throw();
388   };
389
390   /// @brief  Scoped lock idiom.
391   // Acquire the mutex here with a constructor call, then release with
392   // the destructor call in accordance with RAII style.
393   template<typename _Mutex>
394     class lock_guard
395     {
396     public:
397       typedef _Mutex mutex_type;
398
399       explicit lock_guard(mutex_type& __m) : _M_device(__m)
400       { _M_device.lock(); }
401
402       lock_guard(mutex_type& __m, adopt_lock_t __a) : _M_device(__m)
403       { _M_device.lock(); }
404
405       ~lock_guard()
406       { _M_device.unlock(); }
407
408       lock_guard(const lock_guard&) = delete;
409       lock_guard& operator=(const lock_guard&) = delete;
410
411     private:
412       mutex_type&  _M_device;
413     };
414
415   /// unique_lock
416   template<typename _Mutex>
417     class unique_lock
418     {
419     public:
420       typedef _Mutex mutex_type;
421       
422       unique_lock()
423       : _M_device(0), _M_owns(false)
424       { }
425
426       explicit unique_lock(mutex_type& __m)
427       : _M_device(&__m), _M_owns(false)
428       {
429         lock();
430         _M_owns = true;
431       }
432
433       unique_lock(mutex_type& __m, defer_lock_t)
434       : _M_device(&__m), _M_owns(false)
435       { }
436
437       unique_lock(mutex_type& __m, try_to_lock_t)
438       : _M_device(&__m), _M_owns(_M_device->try_lock())
439       { }
440
441       unique_lock(mutex_type& __m, adopt_lock_t)
442       : _M_device(&__m), _M_owns(true)
443       {
444         // XXX calling thread owns mutex
445       }
446
447       template<typename _Clock, typename _Duration>
448         unique_lock(mutex_type& __m, 
449                     const chrono::time_point<_Clock, _Duration>& __atime)
450         : _M_device(&__m), _M_owns(_M_device->try_lock_until(__atime))
451         { }
452
453       template<typename _Rep, typename _Period>
454         unique_lock(mutex_type& __m, 
455                     const chrono::duration<_Rep, _Period>& __rtime)
456         : _M_device(&__m), _M_owns(_M_device->try_lock_for(__rtime))
457         { }
458
459       ~unique_lock()
460       {
461         if (_M_owns)
462           unlock();
463       }
464
465       unique_lock(const unique_lock&) = delete;
466       unique_lock& operator=(const unique_lock&) = delete;
467
468       unique_lock(unique_lock&& __u)
469       : _M_device(__u._M_device), _M_owns(__u._M_owns)
470       {
471         __u._M_device = 0;
472         __u._M_owns = false;
473       }
474
475       unique_lock& operator=(unique_lock&& __u)
476       {
477         if(_M_owns)
478           unlock();
479         
480         unique_lock(std::move(__u)).swap(*this);
481
482         __u._M_device = 0;
483         __u._M_owns = false;
484         
485         return *this;
486       }
487
488       void
489       lock()
490       {
491         if (!_M_device)
492           __throw_system_error((int)errc::operation_not_permitted);
493         else if (_M_owns)
494           __throw_system_error((int)errc::resource_deadlock_would_occur);
495         else
496           {
497             _M_device->lock();
498             _M_owns = true;
499           }
500       }
501
502       bool
503       try_lock()
504       {
505         if (!_M_device)
506           __throw_system_error((int)errc::operation_not_permitted);
507         else if (_M_owns)
508           __throw_system_error((int)errc::resource_deadlock_would_occur);
509         else
510           {
511             _M_owns = _M_device->try_lock();        
512             return _M_owns;
513           }
514       }
515
516       template<typename _Clock, typename _Duration>
517         bool
518         try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
519         {
520           if (!_M_device)
521             __throw_system_error((int)errc::operation_not_permitted);
522           else if (_M_owns)
523             __throw_system_error((int)errc::resource_deadlock_would_occur);
524           else
525             {
526               _M_owns = _M_device->try_lock_until(__atime);
527               return _M_owns;
528             }
529         }
530       
531       template<typename _Rep, typename _Period>
532         bool
533         try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
534         {
535           if (!_M_device)
536             __throw_system_error((int)errc::operation_not_permitted);
537           else if (_M_owns)
538             __throw_system_error((int)errc::resource_deadlock_would_occur);
539           else
540             {
541               _M_owns = _M_device->try_lock_for(__rtime);
542               return _M_owns;
543             }
544          }
545
546       void
547       unlock()
548       {
549         if (!_M_owns)
550           __throw_system_error((int)errc::operation_not_permitted);
551         else if (_M_device)
552           {
553             _M_device->unlock();
554             _M_owns = false;
555           }
556       }
557       
558       void
559       swap(unique_lock&& __u)
560       {
561         std::swap(_M_device, __u._M_device);
562         std::swap(_M_owns, __u._M_owns);
563       }
564
565       mutex_type*
566       release()
567       {
568         mutex_type* __ret = _M_device;
569         _M_device = 0;
570         _M_owns = false;
571         return __ret;
572       }
573
574       bool
575       owns_lock() const
576       { return _M_owns; }
577
578       /* explicit */ operator bool () const
579       { return owns_lock(); }
580
581       mutex_type*
582       mutex() const
583       { return _M_device; }
584
585     private:
586       mutex_type*       _M_device;
587       bool              _M_owns; // XXX use atomic_bool
588     };
589
590   template<typename _Mutex>
591     inline void
592     swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y)
593     { __x.swap(__y); }
594
595   template<typename _Mutex>
596     inline void
597     swap(unique_lock<_Mutex>&& __x, unique_lock<_Mutex>& __y)
598     { __x.swap(__y); }
599
600   template<typename _Mutex>
601     inline void
602     swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>&& __y)
603     { __x.swap(__y); }
604
605   template<int _Idx>
606     struct __unlock_impl
607     {
608       template<typename... _Lock>
609         static void
610         __do_unlock(tuple<_Lock&...>& __locks)
611         {
612           std::get<_Idx>(__locks).unlock();
613           __unlock_impl<_Idx - 1>::__do_unlock(__locks);
614         }
615     };
616   
617   template<>
618     struct __unlock_impl<-1>
619     {
620       template<typename... _Lock>
621         static void
622         __do_unlock(tuple<_Lock&...>&)
623         { }
624     };
625
626   template<int _Idx, bool _Continue = true>
627     struct __try_lock_impl
628     {
629       template<typename... _Lock>
630         static int
631         __do_try_lock(tuple<_Lock&...>& __locks)
632         {
633           if(std::get<_Idx>(__locks).try_lock())
634             {
635               return __try_lock_impl<_Idx + 1,
636                 _Idx + 2 < sizeof...(_Lock)>::__do_try_lock(__locks);
637             }
638           else
639             {
640               __unlock_impl<_Idx>::__do_unlock(__locks);
641               return _Idx;
642             }
643         }
644     };
645   
646   template<int _Idx>
647     struct __try_lock_impl<_Idx, false>
648     {
649       template<typename... _Lock>
650         static int
651         __do_try_lock(tuple<_Lock&...>& __locks)
652         {
653           if(std::get<_Idx>(__locks).try_lock())
654             return -1;
655           else
656             {
657               __unlock_impl<_Idx>::__do_unlock(__locks);
658               return _Idx;
659             }
660         }
661     };
662   
663   /** @brief Generic try_lock.
664    *  @param __l1 Meets Mutex requirements (try_lock() may throw).
665    *  @param __l2 Meets Mutex requirements (try_lock() may throw).
666    *  @param __l3 Meets Mutex requirements (try_lock() may throw).
667    *  @return Returns -1 if all try_lock() calls return true. Otherwise returns 
668    *          a 0-based index corresponding to the argument that returned false.
669    *  @post Either all arguments are locked, or none will be.
670    *
671    *  Sequentially calls try_lock() on each argument.
672    */
673   template<typename _Lock1, typename _Lock2, typename... _Lock3>
674     int
675     try_lock(_Lock1& __l1, _Lock2& __l2, _Lock3&... __l3)
676     {
677       tuple<_Lock1&, _Lock2&, _Lock3&...> __locks(__l1, __l2, __l3...);
678       return __try_lock_impl<0>::__do_try_lock(__locks);
679     }
680
681   template<typename _L1, typename _L2, typename ..._L3>
682     void
683     lock(_L1&, _L2&, _L3&...);
684
685   /// once_flag
686   struct once_flag
687   {
688     typedef __gthread_once_t __native_type;
689
690     once_flag()
691     {
692       __gthread_once_t __tmp = __GTHREAD_ONCE_INIT;
693       _M_once = __tmp;
694     }
695     
696     once_flag(const once_flag&) = delete;
697     once_flag& operator=(const once_flag&) = delete;
698
699     template<typename _Callable, typename... _Args>
700       friend void
701       call_once(once_flag& __once, _Callable __f, _Args&&... __args);
702
703   private:
704     __native_type  _M_once;
705   };
706
707 #ifdef _GLIBCXX_HAVE_TLS
708   extern __thread void* __once_callable;
709   extern __thread void (*__once_call)();
710
711   template<typename _Callable>
712     void __once_call_impl()
713     {
714       (*(_Callable*)__once_callable)();
715     }
716 #else
717   extern function<void()> __once_functor;
718   extern unique_lock<mutex> __once_functor_lock;
719 #endif
720
721   extern "C" void __once_proxy();
722
723   template<typename _Callable, typename... _Args>
724     void
725     call_once(once_flag& __once, _Callable __f, _Args&&... __args)
726     {
727 #ifdef _GLIBCXX_HAVE_TLS
728       auto __bound_functor = bind(__f, __args...);
729       __once_callable = &__bound_functor;
730       __once_call = &__once_call_impl<decltype(__bound_functor)>;
731 #else
732       __once_functor_lock.lock();
733       __once_functor = bind(__f, __args...);
734 #endif
735      
736       int __e = __gthread_once(&(__once._M_once), &__once_proxy);
737
738 #ifndef _GLIBCXX_HAVE_TLS      
739       if (__once_functor_lock)
740         __once_functor_lock.unlock();
741 #endif
742
743       if (__e)
744         __throw_system_error(__e);
745     }
746 }
747
748 #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
749
750 #endif // __GXX_EXPERIMENTAL_CXX0X__
751
752 #endif // _GLIBCXX_MUTEX