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