Patchwork [v3] Use noexcept in <thread> and <mutex>

login
register
mail settings
Submitter Paolo Carlini
Date May 25, 2011, 2:34 p.m.
Message ID <4DDD135F.1070706@oracle.com>
Download mbox | patch
Permalink /patch/97357/
State New
Headers show

Comments

Paolo Carlini - May 25, 2011, 2:34 p.m.
Hi,

tested x86_64-linux, committed to mainline.

Thanks,
Paolo.

////////////////////
2011-05-25  Paolo Carlini  <paolo.carlini@oracle.com>

	* include/std/thread: Use noexcept throughout per the FDIS.
	* include/std/mutex: Likewise.

Patch

Index: include/std/thread
===================================================================
--- include/std/thread	(revision 174185)
+++ include/std/thread	(working copy)
@@ -72,7 +72,7 @@ 
       native_handle_type	_M_thread;
 
     public:
-      id() : _M_thread() { }
+      id() noexcept : _M_thread() { }
 
       explicit
       id(native_handle_type __id) : _M_thread(__id) { }
@@ -82,11 +82,11 @@ 
       friend class hash<thread::id>;
 
       friend bool
-      operator==(thread::id __x, thread::id __y)
+      operator==(thread::id __x, thread::id __y) noexcept
       { return __gthread_equal(__x._M_thread, __y._M_thread); }
 
       friend bool
-      operator<(thread::id __x, thread::id __y)
+      operator<(thread::id __x, thread::id __y) noexcept
       { return __x._M_thread < __y._M_thread; }
 
       template<class _CharT, class _Traits>
@@ -121,11 +121,11 @@ 
     id				_M_id;
 
   public:
-    thread() = default;
+    thread() noexcept = default;
     thread(thread&) = delete;
     thread(const thread&) = delete;
 
-    thread(thread&& __t)
+    thread(thread&& __t) noexcept
     { swap(__t); }
 
     template<typename _Callable, typename... _Args>
@@ -145,7 +145,7 @@ 
 
     thread& operator=(const thread&) = delete;
 
-    thread& operator=(thread&& __t)
+    thread& operator=(thread&& __t) noexcept
     {
       if (joinable())
 	std::terminate();
@@ -154,11 +154,11 @@ 
     }
 
     void
-    swap(thread& __t)
+    swap(thread& __t) noexcept
     { std::swap(_M_id, __t._M_id); }
 
     bool
-    joinable() const
+    joinable() const noexcept
     { return !(_M_id == id()); }
 
     void
@@ -168,7 +168,7 @@ 
     detach();
 
     thread::id
-    get_id() const
+    get_id() const noexcept
     { return _M_id; }
 
     /** @pre thread is joinable
@@ -179,7 +179,7 @@ 
 
     // Returns a value that hints at the number of hardware thread contexts.
     static unsigned int
-    hardware_concurrency()
+    hardware_concurrency() noexcept
     { return 0; }
 
   private:
@@ -198,23 +198,23 @@ 
   inline thread::_Impl_base::~_Impl_base() = default;
 
   inline void
-  swap(thread& __x, thread& __y)
+  swap(thread& __x, thread& __y) noexcept
   { __x.swap(__y); }
 
   inline bool
-  operator!=(thread::id __x, thread::id __y)
+  operator!=(thread::id __x, thread::id __y) noexcept
   { return !(__x == __y); }
 
   inline bool
-  operator<=(thread::id __x, thread::id __y)
+  operator<=(thread::id __x, thread::id __y) noexcept
   { return !(__y < __x); }
 
   inline bool
-  operator>(thread::id __x, thread::id __y)
+  operator>(thread::id __x, thread::id __y) noexcept
   { return __y < __x; }
 
   inline bool
-  operator>=(thread::id __x, thread::id __y)
+  operator>=(thread::id __x, thread::id __y) noexcept
   { return !(__x < __y); }
 
   // DR 889.
@@ -250,12 +250,12 @@ 
 
     /// get_id
     inline thread::id
-    get_id() { return thread::id(__gthread_self()); }
+    get_id() noexcept { return thread::id(__gthread_self()); }
 
 #ifdef _GLIBCXX_USE_SCHED_YIELD
     /// yield
     inline void
-    yield()
+    yield() noexcept
     { __gthread_yield(); }
 #endif
 
Index: include/std/mutex
===================================================================
--- include/std/mutex	(revision 174185)
+++ include/std/mutex	(working copy)
@@ -1,6 +1,6 @@ 
 // <mutex> -*- C++ -*-
 
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -70,9 +70,9 @@ 
     typedef __native_type* 			native_handle_type;
 
 #ifdef __GTHREAD_MUTEX_INIT
-    constexpr mutex() : _M_mutex(__GTHREAD_MUTEX_INIT) { }
+    constexpr mutex() noexcept : _M_mutex(__GTHREAD_MUTEX_INIT) { }
 #else
-    mutex()
+    mutex() noexcept
     {
       // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may)
       __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex);
@@ -95,7 +95,7 @@ 
     }
 
     bool
-    try_lock()
+    try_lock() noexcept
     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_mutex_trylock(&_M_mutex);
@@ -188,7 +188,7 @@ 
     }
 
     bool
-    try_lock()
+    try_lock() noexcept
     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_recursive_mutex_trylock(&_M_mutex);
@@ -247,7 +247,7 @@ 
     }
 
     bool
-    try_lock()
+    try_lock() noexcept
     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_mutex_trylock(&_M_mutex);
@@ -354,7 +354,7 @@ 
     }
 
     bool
-    try_lock()
+    try_lock() noexcept
     {
       // XXX EINVAL, EAGAIN, EBUSY
       return !__gthread_recursive_mutex_trylock(&_M_mutex);
@@ -464,7 +464,7 @@ 
     public:
       typedef _Mutex mutex_type;
 
-      unique_lock()
+      unique_lock() noexcept
       : _M_device(0), _M_owns(false)
       { }
 
@@ -475,7 +475,7 @@ 
 	_M_owns = true;
       }
 
-      unique_lock(mutex_type& __m, defer_lock_t)
+      unique_lock(mutex_type& __m, defer_lock_t) noexcept
       : _M_device(&__m), _M_owns(false)
       { }
 
@@ -510,14 +510,14 @@ 
       unique_lock(const unique_lock&) = delete;
       unique_lock& operator=(const unique_lock&) = delete;
 
-      unique_lock(unique_lock&& __u)
+      unique_lock(unique_lock&& __u) noexcept
       : _M_device(__u._M_device), _M_owns(__u._M_owns)
       {
 	__u._M_device = 0;
 	__u._M_owns = false;
       }
 
-      unique_lock& operator=(unique_lock&& __u)
+      unique_lock& operator=(unique_lock&& __u) noexcept
       {
 	if(_M_owns)
 	  unlock();
@@ -601,14 +601,14 @@ 
       }
 
       void
-      swap(unique_lock& __u)
+      swap(unique_lock& __u) noexcept
       {
 	std::swap(_M_device, __u._M_device);
 	std::swap(_M_owns, __u._M_owns);
       }
 
       mutex_type*
-      release()
+      release() noexcept
       {
 	mutex_type* __ret = _M_device;
 	_M_device = 0;
@@ -617,14 +617,14 @@ 
       }
 
       bool
-      owns_lock() const
+      owns_lock() const noexcept
       { return _M_owns; }
 
-      explicit operator bool() const
+      explicit operator bool() const noexcept
       { return owns_lock(); }
 
       mutex_type*
-      mutex() const
+      mutex() const noexcept
       { return _M_device; }
 
     private:
@@ -634,7 +634,7 @@ 
 
   template<typename _Mutex>
     inline void
-    swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y)
+    swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept
     { __x.swap(__y); }
 
   template<int _Idx>
@@ -759,7 +759,7 @@ 
     __native_type  _M_once;
 
   public:
-    constexpr once_flag() : _M_once(__GTHREAD_ONCE_INIT) { }
+    constexpr once_flag() noexcept : _M_once(__GTHREAD_ONCE_INIT) { }
 
     once_flag(const once_flag&) = delete;
     once_flag& operator=(const once_flag&) = delete;