From 499c61f999dd032510ecd4a70c90bf4410c9762b Mon Sep 17 00:00:00 2001 From: Howard Hinnant Date: Sat, 21 Jul 2012 16:13:09 +0000 Subject: [PATCH] noexcept and constexpr applied to . git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@160604 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/__mutex_base | 49 ++++++++++--------- include/mutex | 44 ++++++++--------- src/mutex.cpp | 17 ++++--- .../thread.once.onceflag/default.pass.cpp | 9 +++- 4 files changed, 65 insertions(+), 54 deletions(-) diff --git a/include/__mutex_base b/include/__mutex_base index 854f02c4..cd734697 100644 --- a/include/__mutex_base +++ b/include/__mutex_base @@ -39,9 +39,9 @@ class _LIBCPP_VISIBLE mutex public: _LIBCPP_INLINE_VISIBILITY #ifndef _LIBCPP_HAS_NO_CONSTEXPR - constexpr mutex() : __m_ PTHREAD_MUTEX_INITIALIZER {} + constexpr mutex() _NOEXCEPT : __m_ PTHREAD_MUTEX_INITIALIZER {} #else - mutex() {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;} + mutex() _NOEXCEPT {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;} #endif ~mutex(); @@ -51,8 +51,8 @@ private: public: void lock(); - bool try_lock(); - void unlock(); + bool try_lock() _NOEXCEPT; + void unlock() _NOEXCEPT; typedef pthread_mutex_t* native_handle_type; _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;} @@ -62,17 +62,19 @@ struct _LIBCPP_VISIBLE defer_lock_t {}; struct _LIBCPP_VISIBLE try_to_lock_t {}; struct _LIBCPP_VISIBLE adopt_lock_t {}; -//constexpr -extern const -defer_lock_t defer_lock; +#if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MUTEX) -//constexpr -extern const -try_to_lock_t try_to_lock; +extern const defer_lock_t defer_lock; +extern const try_to_lock_t try_to_lock; +extern const adopt_lock_t adopt_lock; -//constexpr -extern const -adopt_lock_t adopt_lock; +#else + +constexpr defer_lock_t defer_lock = defer_lock_t(); +constexpr try_to_lock_t try_to_lock = try_to_lock_t(); +constexpr adopt_lock_t adopt_lock = adopt_lock_t(); + +#endif template class _LIBCPP_VISIBLE lock_guard @@ -110,12 +112,12 @@ private: public: _LIBCPP_INLINE_VISIBILITY - unique_lock() : __m_(nullptr), __owns_(false) {} + unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {} _LIBCPP_INLINE_VISIBILITY explicit unique_lock(mutex_type& __m) : __m_(&__m), __owns_(true) {__m_->lock();} _LIBCPP_INLINE_VISIBILITY - unique_lock(mutex_type& __m, defer_lock_t) + unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT : __m_(&__m), __owns_(false) {} _LIBCPP_INLINE_VISIBILITY unique_lock(mutex_type& __m, try_to_lock_t) @@ -145,11 +147,11 @@ private: public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY - unique_lock(unique_lock&& __u) + unique_lock(unique_lock&& __u) _NOEXCEPT : __m_(__u.__m_), __owns_(__u.__owns_) {__u.__m_ = nullptr; __u.__owns_ = false;} _LIBCPP_INLINE_VISIBILITY - unique_lock& operator=(unique_lock&& __u) + unique_lock& operator=(unique_lock&& __u) _NOEXCEPT { if (__owns_) __m_->unlock(); @@ -194,13 +196,13 @@ public: void unlock(); _LIBCPP_INLINE_VISIBILITY - void swap(unique_lock& __u) + void swap(unique_lock& __u) _NOEXCEPT { _VSTD::swap(__m_, __u.__m_); _VSTD::swap(__owns_, __u.__owns_); } _LIBCPP_INLINE_VISIBILITY - mutex_type* release() + mutex_type* release() _NOEXCEPT { mutex_type* __m = __m_; __m_ = nullptr; @@ -209,12 +211,12 @@ public: } _LIBCPP_INLINE_VISIBILITY - bool owns_lock() const {return __owns_;} + bool owns_lock() const _NOEXCEPT {return __owns_;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_EXPLICIT - operator bool () const {return __owns_;} + operator bool () const _NOEXCEPT {return __owns_;} _LIBCPP_INLINE_VISIBILITY - mutex_type* mutex() const {return __m_;} + mutex_type* mutex() const _NOEXCEPT {return __m_;} }; template @@ -280,7 +282,8 @@ unique_lock<_Mutex>::unlock() template inline _LIBCPP_INLINE_VISIBILITY void -swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) {__x.swap(__y);} +swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) _NOEXCEPT + {__x.swap(__y);} struct _LIBCPP_VISIBLE cv_status { diff --git a/include/mutex b/include/mutex index 62b733f4..61f53e0a 100644 --- a/include/mutex +++ b/include/mutex @@ -20,7 +20,7 @@ namespace std class mutex { public: - mutex(); + constexpr mutex() noexcept; ~mutex(); mutex(const mutex&) = delete; @@ -44,7 +44,7 @@ public: recursive_mutex& operator=(const recursive_mutex&) = delete; void lock(); - bool try_lock(); + bool try_lock() noexcept; void unlock(); typedef pthread_mutex_t* native_handle_type; @@ -79,7 +79,7 @@ public: recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; void lock(); - bool try_lock(); + bool try_lock() noexcept; template bool try_lock_for(const chrono::duration& rel_time); template @@ -114,9 +114,9 @@ class unique_lock { public: typedef Mutex mutex_type; - unique_lock(); + unique_lock() noexcept; explicit unique_lock(mutex_type& m); - unique_lock(mutex_type& m, defer_lock_t); + unique_lock(mutex_type& m, defer_lock_t) noexcept; unique_lock(mutex_type& m, try_to_lock_t); unique_lock(mutex_type& m, adopt_lock_t); template @@ -128,8 +128,8 @@ public: unique_lock(unique_lock const&) = delete; unique_lock& operator=(unique_lock const&) = delete; - unique_lock(unique_lock&& u); - unique_lock& operator=(unique_lock&& u); + unique_lock(unique_lock&& u) noexcept; + unique_lock& operator=(unique_lock&& u) noexcept; void lock(); bool try_lock(); @@ -141,16 +141,16 @@ public: void unlock(); - void swap(unique_lock& u); - mutex_type* release(); + void swap(unique_lock& u) noexcept; + mutex_type* release() noexcept; - bool owns_lock() const; - explicit operator bool () const; - mutex_type* mutex() const; + bool owns_lock() const noexcept; + explicit operator bool () const noexcept; + mutex_type* mutex() const noexcept; }; template - void swap(unique_lock& x, unique_lock& y); + void swap(unique_lock& x, unique_lock& y) noexcept; template int try_lock(L1&, L2&, L3&...); @@ -159,7 +159,7 @@ template struct once_flag { - constexpr once_flag(); + constexpr once_flag() noexcept; once_flag(const once_flag&) = delete; once_flag& operator=(const once_flag&) = delete; @@ -201,8 +201,8 @@ private: public: void lock(); - bool try_lock(); - void unlock(); + bool try_lock() _NOEXCEPT; + void unlock() _NOEXCEPT; typedef pthread_mutex_t* native_handle_type; _LIBCPP_INLINE_VISIBILITY @@ -224,14 +224,14 @@ private: public: void lock(); - bool try_lock(); + bool try_lock() _NOEXCEPT; template _LIBCPP_INLINE_VISIBILITY bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {return try_lock_until(chrono::steady_clock::now() + __d);} template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t); - void unlock(); + void unlock() _NOEXCEPT; }; template @@ -267,14 +267,14 @@ private: public: void lock(); - bool try_lock(); + bool try_lock() _NOEXCEPT; template _LIBCPP_INLINE_VISIBILITY bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {return try_lock_until(chrono::steady_clock::now() + __d);} template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t); - void unlock(); + void unlock() _NOEXCEPT; }; template @@ -442,8 +442,8 @@ template struct _LIBCPP_VISIBLE once_flag { _LIBCPP_INLINE_VISIBILITY - // constexpr - once_flag() {} + _LIBCPP_CONSTEXPR + once_flag() _NOEXCEPT : __state_(0) {} private: once_flag(const once_flag&); // = delete; diff --git a/src/mutex.cpp b/src/mutex.cpp index 9aa051be..42195aa8 100644 --- a/src/mutex.cpp +++ b/src/mutex.cpp @@ -7,6 +7,7 @@ // //===----------------------------------------------------------------------===// +#define _LIBCPP_BUILDING_MUTEX #include "mutex" #include "limits" #include "system_error" @@ -32,13 +33,13 @@ mutex::lock() } bool -mutex::try_lock() +mutex::try_lock() _NOEXCEPT { return pthread_mutex_trylock(&__m_) == 0; } void -mutex::unlock() +mutex::unlock() _NOEXCEPT { int ec = pthread_mutex_unlock(&__m_); assert(ec == 0); @@ -90,14 +91,14 @@ recursive_mutex::lock() } void -recursive_mutex::unlock() +recursive_mutex::unlock() _NOEXCEPT { int e = pthread_mutex_unlock(&__m_); assert(e == 0); } bool -recursive_mutex::try_lock() +recursive_mutex::try_lock() _NOEXCEPT { return pthread_mutex_trylock(&__m_) == 0; } @@ -124,7 +125,7 @@ timed_mutex::lock() } bool -timed_mutex::try_lock() +timed_mutex::try_lock() _NOEXCEPT { unique_lock lk(__m_, try_to_lock); if (lk.owns_lock() && !__locked_) @@ -136,7 +137,7 @@ timed_mutex::try_lock() } void -timed_mutex::unlock() +timed_mutex::unlock() _NOEXCEPT { lock_guard _(__m_); __locked_ = false; @@ -175,7 +176,7 @@ recursive_timed_mutex::lock() } bool -recursive_timed_mutex::try_lock() +recursive_timed_mutex::try_lock() _NOEXCEPT { pthread_t id = pthread_self(); unique_lock lk(__m_, try_to_lock); @@ -191,7 +192,7 @@ recursive_timed_mutex::try_lock() } void -recursive_timed_mutex::unlock() +recursive_timed_mutex::unlock() _NOEXCEPT { unique_lock lk(__m_); if (--__count_ == 0) diff --git a/test/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp b/test/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp index dc4a0740..6995f064 100644 --- a/test/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp +++ b/test/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp @@ -11,11 +11,18 @@ // struct once_flag; -// constexpr once_flag(); +// constexpr once_flag() noexcept; #include int main() { + { std::once_flag f; + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::once_flag f; + } +#endif }