11.2.0/bits/std_mutex.h

// std::mutex implementation -*- C++ -*-

// Copyright (C) 2003-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file bits/std_mutex.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{mutex}
 */

#ifndef _GLIBCXX_MUTEX_H
#define _GLIBCXX_MUTEX_H 1

#pragma GCC system_header

#if __cplusplus < 201103L
# include <bits/c++0x_warning.h>
#else

#include <system_error>
#include <bits/functexcept.h>
#include <bits/gthr.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   * @defgroup mutexes Mutexes
   * @ingroup concurrency
   *
   * Classes for mutex support.
   * @{
   */

#ifdef _GLIBCXX_HAS_GTHREADS
  // Common base class for std::mutex and std::timed_mutex
  class __mutex_base
  {
  protected:
    typedef __gthread_mutex_t                   __native_type;

#ifdef __GTHREAD_MUTEX_INIT
    __native_type  _M_mutex = __GTHREAD_MUTEX_INIT;

    constexpr __mutex_base() noexcept = default;
#else
    __native_type  _M_mutex;

    __mutex_base() noexcept
    {
      // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
      __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
    }

    ~__mutex_base() noexcept { __gthread_mutex_destroy(&_M_mutex); }
#endif

    __mutex_base(const __mutex_base&) = delete;
    __mutex_base& operator=(const __mutex_base&) = delete;
  };

  /// The standard mutex type.
  class mutex : private __mutex_base
  {
  public:
    typedef __native_type*                      native_handle_type;

#ifdef __GTHREAD_MUTEX_INIT
    constexpr
#endif
    mutex() noexcept = default;
    ~mutex() = default;

    mutex(const mutex&) = delete;
    mutex& operator=(const mutex&) = delete;

    void
    lock()
    {
      int __e = __gthread_mutex_lock(&_M_mutex);

      // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
      if (__e)
        __throw_system_error(__e);
    }

    bool
    try_lock() noexcept
    {
      // XXX EINVAL, EAGAIN, EBUSY
      return !__gthread_mutex_trylock(&_M_mutex);
    }

    void
    unlock()
    {
      // XXX EINVAL, EAGAIN, EPERM
      __gthread_mutex_unlock(&_M_mutex);
    }

    native_handle_type
    native_handle() noexcept
    { return &_M_mutex; }
  };

  // Implementation details for std::condition_variable
  class __condvar
  {
    using timespec = __gthread_time_t;

  public:
    __condvar() noexcept
    {
#ifndef __GTHREAD_COND_INIT
      __GTHREAD_COND_INIT_FUNCTION(&_M_cond);
#endif
    }

    ~__condvar()
    {
      int __e __attribute__((__unused__)) = __gthread_cond_destroy(&_M_cond);
      __glibcxx_assert(__e != EBUSY); // threads are still blocked
    }

    __condvar(const __condvar&) = delete;
    __condvar& operator=(const __condvar&) = delete;

    __gthread_cond_t* native_handle() noexcept { return &_M_cond; }

    // Expects: Calling thread has locked __m.
    void
    wait(mutex& __m) noexcept
    {
      int __e __attribute__((__unused__))
        = __gthread_cond_wait(&_M_cond, __m.native_handle());
      __glibcxx_assert(__e == 0);
    }

    void
    wait_until(mutex& __m, timespec& __abs_time) noexcept
    {
      __gthread_cond_timedwait(&_M_cond, __m.native_handle(), &__abs_time);
    }

#ifdef _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT
    void
    wait_until(mutex& __m, clockid_t __clock, timespec& __abs_time) noexcept
    {
      pthread_cond_clockwait(&_M_cond, __m.native_handle(), __clock,
                             &__abs_time);
    }
#endif

    void
    notify_one() noexcept
    {
      int __e __attribute__((__unused__)) = __gthread_cond_signal(&_M_cond);
      __glibcxx_assert(__e == 0);
    }

    void
    notify_all() noexcept
    {
      int __e __attribute__((__unused__)) = __gthread_cond_broadcast(&_M_cond);
      __glibcxx_assert(__e == 0);
    }

  protected:
#ifdef __GTHREAD_COND_INIT
    __gthread_cond_t _M_cond = __GTHREAD_COND_INIT;
#else
    __gthread_cond_t _M_cond;
#endif
  };

#endif // _GLIBCXX_HAS_GTHREADS

  /// Do not acquire ownership of the mutex.
  struct defer_lock_t { explicit defer_lock_t() = default; };

  /// Try to acquire ownership of the mutex without blocking.
  struct try_to_lock_t { explicit try_to_lock_t() = default; };

  /// Assume the calling thread has already obtained mutex ownership
  /// and manage it.
  struct adopt_lock_t { explicit adopt_lock_t() = default; };

  /// Tag used to prevent a scoped lock from acquiring ownership of a mutex.
  _GLIBCXX17_INLINE constexpr defer_lock_t      defer_lock { };

  /// Tag used to prevent a scoped lock from blocking if a mutex is locked.
  _GLIBCXX17_INLINE constexpr try_to_lock_t     try_to_lock { };

  /// Tag used to make a scoped lock take ownership of a locked mutex.
  _GLIBCXX17_INLINE constexpr adopt_lock_t      adopt_lock { };

  /** @brief A simple scoped lock type.
   *
   * A lock_guard controls mutex ownership within a scope, releasing
   * ownership in the destructor.
   */
  template<typename _Mutex>
    class lock_guard
    {
    public:
      typedef _Mutex mutex_type;

      explicit lock_guard(mutex_type& __m) : _M_device(__m)
      { _M_device.lock(); }

      lock_guard(mutex_type& __m, adopt_lock_t) noexcept : _M_device(__m)
      { } // calling thread owns mutex

      ~lock_guard()
      { _M_device.unlock(); }

      lock_guard(const lock_guard&) = delete;
      lock_guard& operator=(const lock_guard&) = delete;

    private:
      mutex_type&  _M_device;
    };

  /// @} group mutexes
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#endif // C++11
#endif // _GLIBCXX_MUTEX_H
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	6443 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	// std::mutex implementation -- 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 bits/std_mutex.h
26	* This is an internal header file, included by other library headers.
27	* Do not attempt to use it directly. @headername{mutex}
28	*/
29
30	#ifndef _GLIBCXX_MUTEX_H
31	#define _GLIBCXX_MUTEX_H 1
32
33	#pragma GCC system_header
34
35	#if __cplusplus < 201103L
36	# include <bits/c++0x_warning.h>
37	#else
38
39	#include <system_error>
40	#include <bits/functexcept.h>
41	#include <bits/gthr.h>
42
43	namespace std _GLIBCXX_VISIBILITY(default)
44	{
45	_GLIBCXX_BEGIN_NAMESPACE_VERSION
46
47	/**
48	* @defgroup mutexes Mutexes
49	* @ingroup concurrency
50	*
51	* Classes for mutex support.
52	* @{
53	*/
54
55	#ifdef _GLIBCXX_HAS_GTHREADS
56	// Common base class for std::mutex and std::timed_mutex
57	class __mutex_base
58	{
59	protected:
60	typedef __gthread_mutex_t __native_type;
61
62	#ifdef __GTHREAD_MUTEX_INIT
63	__native_type _M_mutex = __GTHREAD_MUTEX_INIT;
64
65	constexpr __mutex_base() noexcept = default;
66	#else
67	__native_type _M_mutex;
68
69	__mutex_base() noexcept
70	{
71	// XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
72	__GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
73	}
74
75	~__mutex_base() noexcept { __gthread_mutex_destroy(&_M_mutex); }
76	#endif
77
78	__mutex_base(const __mutex_base&) = delete;
79	__mutex_base& operator=(const __mutex_base&) = delete;
80	};
81
82	/// The standard mutex type.
83	class mutex : private __mutex_base
84	{
85	public:
86	typedef __native_type* native_handle_type;
87
88	#ifdef __GTHREAD_MUTEX_INIT
89	constexpr
90	#endif
91	mutex() noexcept = default;
92	~mutex() = default;
93
94	mutex(const mutex&) = delete;
95	mutex& operator=(const mutex&) = delete;
96
97	void
98	lock()
99	{
100	int __e = __gthread_mutex_lock(&_M_mutex);
101
102	// EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
103	if (__e)
104	__throw_system_error(__e);
105	}
106
107	bool
108	try_lock() noexcept
109	{
110	// XXX EINVAL, EAGAIN, EBUSY
111	return !__gthread_mutex_trylock(&_M_mutex);
112	}
113
114	void
115	unlock()
116	{
117	// XXX EINVAL, EAGAIN, EPERM
118	__gthread_mutex_unlock(&_M_mutex);
119	}
120
121	native_handle_type
122	native_handle() noexcept
123	{ return &_M_mutex; }
124	};
125
126	// Implementation details for std::condition_variable
127	class __condvar
128	{
129	using timespec = __gthread_time_t;
130
131	public:
132	__condvar() noexcept
133	{
134	#ifndef __GTHREAD_COND_INIT
135	__GTHREAD_COND_INIT_FUNCTION(&_M_cond);
136	#endif
137	}
138
139	~__condvar()
140	{
141	int __e __attribute__((__unused__)) = __gthread_cond_destroy(&_M_cond);
142	__glibcxx_assert(__e != EBUSY); // threads are still blocked
143	}
144
145	__condvar(const __condvar&) = delete;
146	__condvar& operator=(const __condvar&) = delete;
147
148	__gthread_cond_t* native_handle() noexcept { return &_M_cond; }
149
150	// Expects: Calling thread has locked __m.
151	void
152	wait(mutex& __m) noexcept
153	{
154	int __e __attribute__((__unused__))
155	= __gthread_cond_wait(&_M_cond, __m.native_handle());
156	__glibcxx_assert(__e == 0);
157	}
158
159	void
160	wait_until(mutex& __m, timespec& __abs_time) noexcept
161	{
162	__gthread_cond_timedwait(&_M_cond, __m.native_handle(), &__abs_time);
163	}
164
165	#ifdef _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT
166	void
167	wait_until(mutex& __m, clockid_t __clock, timespec& __abs_time) noexcept
168	{
169	pthread_cond_clockwait(&_M_cond, __m.native_handle(), __clock,
170	&__abs_time);
171	}
172	#endif
173
174	void
175	notify_one() noexcept
176	{
177	int __e __attribute__((__unused__)) = __gthread_cond_signal(&_M_cond);
178	__glibcxx_assert(__e == 0);
179	}
180
181	void
182	notify_all() noexcept
183	{
184	int __e __attribute__((__unused__)) = __gthread_cond_broadcast(&_M_cond);
185	__glibcxx_assert(__e == 0);
186	}
187
188	protected:
189	#ifdef __GTHREAD_COND_INIT
190	__gthread_cond_t _M_cond = __GTHREAD_COND_INIT;
191	#else
192	__gthread_cond_t _M_cond;
193	#endif
194	};
195
196	#endif // _GLIBCXX_HAS_GTHREADS
197
198	/// Do not acquire ownership of the mutex.
199	struct defer_lock_t { explicit defer_lock_t() = default; };
200
201	/// Try to acquire ownership of the mutex without blocking.
202	struct try_to_lock_t { explicit try_to_lock_t() = default; };
203
204	/// Assume the calling thread has already obtained mutex ownership
205	/// and manage it.
206	struct adopt_lock_t { explicit adopt_lock_t() = default; };
207
208	/// Tag used to prevent a scoped lock from acquiring ownership of a mutex.
209	_GLIBCXX17_INLINE constexpr defer_lock_t defer_lock { };
210
211	/// Tag used to prevent a scoped lock from blocking if a mutex is locked.
212	_GLIBCXX17_INLINE constexpr try_to_lock_t try_to_lock { };
213
214	/// Tag used to make a scoped lock take ownership of a locked mutex.
215	_GLIBCXX17_INLINE constexpr adopt_lock_t adopt_lock { };
216
217	/** @brief A simple scoped lock type.
218	*
219	* A lock_guard controls mutex ownership within a scope, releasing
220	* ownership in the destructor.
221	*/
222	template<typename _Mutex>
223	class lock_guard
224	{
225	public:
226	typedef _Mutex mutex_type;
227
228	explicit lock_guard(mutex_type& __m) : _M_device(__m)
229	{ _M_device.lock(); }
230
231	lock_guard(mutex_type& __m, adopt_lock_t) noexcept : _M_device(__m)
232	{ } // calling thread owns mutex
233
234	~lock_guard()
235	{ _M_device.unlock(); }
236
237	lock_guard(const lock_guard&) = delete;
238	lock_guard& operator=(const lock_guard&) = delete;
239
240	private:
241	mutex_type& _M_device;
242	};
243
244	/// @} group mutexes
245	_GLIBCXX_END_NAMESPACE_VERSION
246	} // namespace
247	#endif // C++11
248	#endif // _GLIBCXX_MUTEX_H