libstdc++
concurrence.h
Go to the documentation of this file.
1 // Support for concurrent programing -*- C++ -*-
2 
3 // Copyright (C) 2003-2021 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 /** @file ext/concurrence.h
26  * This file is a GNU extension to the Standard C++ Library.
27  */
28 
29 #ifndef _CONCURRENCE_H
30 #define _CONCURRENCE_H 1
31 
32 #pragma GCC system_header
33 
34 #include <exception>
35 #include <bits/gthr.h>
36 #include <bits/functexcept.h>
37 #include <bits/cpp_type_traits.h>
38 #include <ext/type_traits.h>
39 
40 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
41 {
42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
43 
44  // Available locking policies:
45  // _S_single single-threaded code that doesn't need to be locked.
46  // _S_mutex multi-threaded code that requires additional support
47  // from gthr.h or abstraction layers in concurrence.h.
48  // _S_atomic multi-threaded code using atomic operations.
49  enum _Lock_policy { _S_single, _S_mutex, _S_atomic };
50 
51  // Compile time constant that indicates prefered locking policy in
52  // the current configuration.
53  static const _Lock_policy __default_lock_policy =
54 #ifndef __GTHREADS
55  _S_single;
56 #elif defined _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY
57  _S_atomic;
58 #else
59  _S_mutex;
60 #endif
61 
62  // NB: As this is used in libsupc++, need to only depend on
63  // exception. No stdexception classes, no use of std::string.
64  class __concurrence_lock_error : public std::exception
65  {
66  public:
67  virtual char const*
68  what() const throw()
69  { return "__gnu_cxx::__concurrence_lock_error"; }
70  };
71 
72  class __concurrence_unlock_error : public std::exception
73  {
74  public:
75  virtual char const*
76  what() const throw()
77  { return "__gnu_cxx::__concurrence_unlock_error"; }
78  };
79 
80  class __concurrence_broadcast_error : public std::exception
81  {
82  public:
83  virtual char const*
84  what() const throw()
85  { return "__gnu_cxx::__concurrence_broadcast_error"; }
86  };
87 
88  class __concurrence_wait_error : public std::exception
89  {
90  public:
91  virtual char const*
92  what() const throw()
93  { return "__gnu_cxx::__concurrence_wait_error"; }
94  };
95 
96  // Substitute for concurrence_error object in the case of -fno-exceptions.
97  inline void
98  __throw_concurrence_lock_error()
99  { _GLIBCXX_THROW_OR_ABORT(__concurrence_lock_error()); }
100 
101  inline void
102  __throw_concurrence_unlock_error()
103  { _GLIBCXX_THROW_OR_ABORT(__concurrence_unlock_error()); }
104 
105 #ifdef __GTHREAD_HAS_COND
106  inline void
107  __throw_concurrence_broadcast_error()
108  { _GLIBCXX_THROW_OR_ABORT(__concurrence_broadcast_error()); }
109 
110  inline void
111  __throw_concurrence_wait_error()
112  { _GLIBCXX_THROW_OR_ABORT(__concurrence_wait_error()); }
113 #endif
114 
115  class __mutex
116  {
117  private:
118 #if __GTHREADS && defined __GTHREAD_MUTEX_INIT
119  __gthread_mutex_t _M_mutex = __GTHREAD_MUTEX_INIT;
120 #else
121  __gthread_mutex_t _M_mutex;
122 #endif
123 
124  __mutex(const __mutex&);
125  __mutex& operator=(const __mutex&);
126 
127  public:
128  __mutex()
129  {
130 #if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT
131  if (__gthread_active_p())
132  __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
133 #endif
134  }
135 
136 #if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT
137  ~__mutex()
138  {
139  if (__gthread_active_p())
140  __gthread_mutex_destroy(&_M_mutex);
141  }
142 #endif
143 
144  void lock()
145  {
146 #if __GTHREADS
147  if (__gthread_active_p())
148  {
149  if (__gthread_mutex_lock(&_M_mutex) != 0)
150  __throw_concurrence_lock_error();
151  }
152 #endif
153  }
154 
155  void unlock()
156  {
157 #if __GTHREADS
158  if (__gthread_active_p())
159  {
160  if (__gthread_mutex_unlock(&_M_mutex) != 0)
161  __throw_concurrence_unlock_error();
162  }
163 #endif
164  }
165 
166  __gthread_mutex_t* gthread_mutex(void)
167  { return &_M_mutex; }
168  };
169 
170  class __recursive_mutex
171  {
172  private:
173 #if __GTHREADS && defined __GTHREAD_RECURSIVE_MUTEX_INIT
174  __gthread_recursive_mutex_t _M_mutex = __GTHREAD_RECURSIVE_MUTEX_INIT;
175 #else
176  __gthread_recursive_mutex_t _M_mutex;
177 #endif
178 
179  __recursive_mutex(const __recursive_mutex&);
180  __recursive_mutex& operator=(const __recursive_mutex&);
181 
182  public:
183  __recursive_mutex()
184  {
185 #if __GTHREADS && ! defined __GTHREAD_RECURSIVE_MUTEX_INIT
186  if (__gthread_active_p())
187  __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex);
188 #endif
189  }
190 
191 #if __GTHREADS && ! defined __GTHREAD_RECURSIVE_MUTEX_INIT
192  ~__recursive_mutex()
193  {
194  if (__gthread_active_p())
195  __gthread_recursive_mutex_destroy(&_M_mutex);
196  }
197 #endif
198 
199  void lock()
200  {
201 #if __GTHREADS
202  if (__gthread_active_p())
203  {
204  if (__gthread_recursive_mutex_lock(&_M_mutex) != 0)
205  __throw_concurrence_lock_error();
206  }
207 #endif
208  }
209 
210  void unlock()
211  {
212 #if __GTHREADS
213  if (__gthread_active_p())
214  {
215  if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0)
216  __throw_concurrence_unlock_error();
217  }
218 #endif
219  }
220 
221  __gthread_recursive_mutex_t* gthread_recursive_mutex(void)
222  { return &_M_mutex; }
223  };
224 
225  /// Scoped lock idiom.
226  // Acquire the mutex here with a constructor call, then release with
227  // the destructor call in accordance with RAII style.
229  {
230  public:
231  typedef __mutex __mutex_type;
232 
233  private:
234  __mutex_type& _M_device;
235 
237  __scoped_lock& operator=(const __scoped_lock&);
238 
239  public:
240  explicit __scoped_lock(__mutex_type& __name) : _M_device(__name)
241  { _M_device.lock(); }
242 
243  ~__scoped_lock() throw()
244  { _M_device.unlock(); }
245  };
246 
247 #ifdef __GTHREAD_HAS_COND
248  class __cond
249  {
250  private:
251 #if __GTHREADS && defined __GTHREAD_COND_INIT
252  __gthread_cond_t _M_cond = __GTHREAD_COND_INIT;
253 #else
254  __gthread_cond_t _M_cond;
255 #endif
256 
257  __cond(const __cond&);
258  __cond& operator=(const __cond&);
259 
260  public:
261  __cond()
262  {
263 #if __GTHREADS && ! defined __GTHREAD_COND_INIT
264  if (__gthread_active_p())
265  __GTHREAD_COND_INIT_FUNCTION(&_M_cond);
266 #endif
267  }
268 
269 #if __GTHREADS && ! defined __GTHREAD_COND_INIT
270  ~__cond()
271  {
272  if (__gthread_active_p())
273  __gthread_cond_destroy(&_M_cond);
274  }
275 #endif
276 
277  void broadcast()
278  {
279 #if __GTHREADS
280  if (__gthread_active_p())
281  {
282  if (__gthread_cond_broadcast(&_M_cond) != 0)
283  __throw_concurrence_broadcast_error();
284  }
285 #endif
286  }
287 
288  void wait(__mutex *mutex)
289  {
290 #if __GTHREADS
291  {
292  if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0)
293  __throw_concurrence_wait_error();
294  }
295 #endif
296  }
297 
298  void wait_recursive(__recursive_mutex *mutex)
299  {
300 #if __GTHREADS
301  {
302  if (__gthread_cond_wait_recursive(&_M_cond,
303  mutex->gthread_recursive_mutex())
304  != 0)
305  __throw_concurrence_wait_error();
306  }
307 #endif
308  }
309  };
310 #endif
311 
312 _GLIBCXX_END_NAMESPACE_VERSION
313 } // namespace
314 
315 #endif
void lock(_L1 &__l1, _L2 &__l2, _L3 &... __l3)
Generic lock.
Definition: mutex:648
GNU extensions for public use.
Base class for all library exceptions.
Definition: exception.h:61
Scoped lock idiom.
Definition: concurrence.h:229