1// condition_variable -*- C++ -*- 2 3// Copyright (C) 2008-2022 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 3, 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// Under Section 7 of GPL version 3, you are granted additional 17// permissions described in the GCC Runtime Library Exception, version 18// 3.1, as published by the Free Software Foundation. 19 20// You should have received a copy of the GNU General Public License and 21// a copy of the GCC Runtime Library Exception along with this program; 22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23// <http://www.gnu.org/licenses/>. 24 25#include <condition_variable> 26#include <cstdlib> 27 28#ifdef _GLIBCXX_HAS_GTHREADS 29 30namespace std _GLIBCXX_VISIBILITY(default) 31{ 32_GLIBCXX_BEGIN_NAMESPACE_VERSION 33 34 condition_variable::condition_variable() noexcept = default; 35 36 condition_variable::~condition_variable() noexcept = default; 37 38 void 39 condition_variable::wait(unique_lock<mutex>& __lock) 40 { 41 _M_cond.wait(*__lock.mutex()); 42 } 43 44 void 45 condition_variable::notify_one() noexcept 46 { 47 _M_cond.notify_one(); 48 } 49 50 void 51 condition_variable::notify_all() noexcept 52 { 53 _M_cond.notify_all(); 54 } 55 56 extern void 57 __at_thread_exit(__at_thread_exit_elt*); 58 59 namespace 60 { 61 __gthread_key_t key; 62 63 void run(void* p) 64 { 65 auto elt = (__at_thread_exit_elt*)p; 66 while (elt) 67 { 68 auto next = elt->_M_next; 69 elt->_M_cb(elt); 70 elt = next; 71 } 72 } 73 74 void run() 75 { 76 auto elt = (__at_thread_exit_elt*)__gthread_getspecific(key); 77 __gthread_setspecific(key, nullptr); 78 run(elt); 79 } 80 81 struct notifier final : __at_thread_exit_elt 82 { 83 notifier(condition_variable& cv, unique_lock<mutex>& l) 84 : cv(&cv), mx(l.release()) 85 { 86 _M_cb = ¬ifier::run; 87 __at_thread_exit(this); 88 } 89 90 ~notifier() 91 { 92 mx->unlock(); 93 cv->notify_all(); 94 } 95 96 condition_variable* cv; 97 mutex* mx; 98 99 static void run(void* p) { delete static_cast<notifier*>(p); } 100 }; 101 102 103 void key_init() { 104 struct key_s { 105 key_s() { __gthread_key_create (&key, run); } 106 ~key_s() { __gthread_key_delete (key); } 107 }; 108 static key_s ks; 109 // Also make sure the callbacks are run by std::exit. 110 std::atexit (run); 111 } 112 } 113 114 void 115 __at_thread_exit(__at_thread_exit_elt* elt) 116 { 117 static __gthread_once_t once = __GTHREAD_ONCE_INIT; 118 __gthread_once (&once, key_init); 119 120 elt->_M_next = (__at_thread_exit_elt*)__gthread_getspecific(key); 121 __gthread_setspecific(key, elt); 122 } 123 124 void 125 notify_all_at_thread_exit(condition_variable& cv, unique_lock<mutex> l) 126 { 127 (void) new notifier{cv, l}; 128 } 129 130_GLIBCXX_END_NAMESPACE_VERSION 131} // namespace 132 133#endif // _GLIBCXX_HAS_GTHREADS 134