The C and C++ Include Header Files

/usr/include/c++/11/ext/concurrence.h


$ cat -n /usr/include/c++/11/ext/concurrence.h

     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.
   228	  class __scoped_lock
   229	  {
   230	  public:
   231	    typedef __mutex __mutex_type;
   232	
   233	  private:
   234	    __mutex_type& _M_device;
   235	
   236	    __scoped_lock(const __scoped_lock&);
   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