libcxx initial import
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@103490 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/__mutex_base b/include/__mutex_base
new file mode 100644
index 0000000..40d066d
--- /dev/null
+++ b/include/__mutex_base
@@ -0,0 +1,385 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊThe LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MUTEX_BASE
+#define _LIBCPP___MUTEX_BASE
+
+#include <__config>
+#include <chrono>
+#include <system_error>
+#include <pthread.h>
+
+#pragma GCC system_header
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class mutex
+{
+ pthread_mutex_t __m_;
+
+public:
+ mutex() {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
+ ~mutex();
+
+private:
+ mutex(const mutex&);// = delete;
+ mutex& operator=(const mutex&);// = delete;
+
+public:
+ void lock();
+ bool try_lock();
+ void unlock();
+
+ typedef pthread_mutex_t* native_handle_type;
+ native_handle_type native_handle() {return &__m_;}
+};
+
+struct defer_lock_t {};
+struct try_to_lock_t {};
+struct adopt_lock_t {};
+
+//constexpr
+extern const
+defer_lock_t defer_lock;
+
+//constexpr
+extern const
+try_to_lock_t try_to_lock;
+
+//constexpr
+extern const
+adopt_lock_t adopt_lock;
+
+template <class _Mutex>
+class lock_guard
+{
+public:
+ typedef _Mutex mutex_type;
+
+private:
+ mutex_type& __m_;
+public:
+
+ explicit lock_guard(mutex_type& __m)
+ : __m_(__m) {__m_.lock();}
+ lock_guard(mutex_type& __m, adopt_lock_t)
+ : __m_(__m) {}
+ ~lock_guard() {__m_.unlock();}
+
+private:
+ lock_guard(lock_guard const&);// = delete;
+ lock_guard& operator=(lock_guard const&);// = delete;
+};
+
+template <class _Mutex>
+class unique_lock
+{
+public:
+ typedef _Mutex mutex_type;
+
+private:
+ mutex_type* __m_;
+ bool __owns_;
+
+public:
+ unique_lock() : __m_(nullptr), __owns_(false) {}
+ explicit unique_lock(mutex_type& __m)
+ : __m_(&__m), __owns_(true) {__m_->lock();}
+ unique_lock(mutex_type& __m, defer_lock_t)
+ : __m_(&__m), __owns_(false) {}
+ unique_lock(mutex_type& __m, try_to_lock_t)
+ : __m_(&__m), __owns_(__m.try_lock()) {}
+ unique_lock(mutex_type& __m, adopt_lock_t)
+ : __m_(&__m), __owns_(true) {}
+ template <class _Clock, class _Duration>
+ unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
+ : __m_(&__m), __owns_(__m.try_lock_until(__t)) {}
+ template <class _Rep, class _Period>
+ unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
+ : __m_(&__m), __owns_(__m.try_lock_for(__d)) {}
+ ~unique_lock()
+ {
+ if (__owns_)
+ __m_->unlock();
+ }
+
+private:
+ unique_lock(unique_lock const&); // = delete;
+ unique_lock& operator=(unique_lock const&); // = delete;
+
+public:
+#ifdef _LIBCPP_MOVE
+ unique_lock(unique_lock&& __u)
+ : __m_(__u.__m_), __owns_(__u.__owns_)
+ {__u.__m_ = nullptr; __u.__owns_ = false;}
+ unique_lock& operator=(unique_lock&& __u)
+ {
+ if (__owns_)
+ __m_->unlock();
+ __m_ = __u.__m_;
+ __owns_ = __u.__owns_;
+ __u.__m_ = nullptr;
+ __u.__owns_ = false;
+ return *this;
+ }
+#endif
+
+ void lock();
+ bool try_lock();
+
+ template <class _Rep, class _Period>
+ bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
+ template <class _Clock, class _Duration>
+ bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
+
+ void unlock();
+
+ void swap(unique_lock& __u)
+ {
+ _STD::swap(__m_, __u.__m_);
+ _STD::swap(__owns_, __u.__owns_);
+ }
+ mutex_type* release()
+ {
+ mutex_type* __m = __m_;
+ __m_ = nullptr;
+ __owns_ = false;
+ return __m;
+ }
+
+ bool owns_lock() const {return __owns_;}
+// explicit
+ operator bool () const {return __owns_;}
+ mutex_type* mutex() const {return __m_;}
+};
+
+template <class _Mutex>
+void
+unique_lock<_Mutex>::lock()
+{
+ if (__m_ == nullptr)
+ __throw_system_error(EPERM, "unique_lock::lock: references null mutex");
+ if (__owns_)
+ __throw_system_error(EDEADLK, "unique_lock::lock: already locked");
+ __m_->lock();
+ __owns_ = true;
+}
+
+template <class _Mutex>
+bool
+unique_lock<_Mutex>::try_lock()
+{
+ if (__m_ == nullptr)
+ __throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
+ if (__owns_)
+ __throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
+ __owns_ = __m_->try_lock();
+ return __owns_;
+}
+
+template <class _Mutex>
+template <class _Rep, class _Period>
+bool
+unique_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
+{
+ if (__m_ == nullptr)
+ __throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
+ if (__owns_)
+ __throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
+ __owns_ = __m_->try_lock_for(__d);
+ return __owns_;
+}
+
+template <class _Mutex>
+template <class _Clock, class _Duration>
+bool
+unique_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
+{
+ if (__m_ == nullptr)
+ __throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
+ if (__owns_)
+ __throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
+ __owns_ = __m_->try_lock_until(__t);
+ return __owns_;
+}
+
+template <class _Mutex>
+void
+unique_lock<_Mutex>::unlock()
+{
+ if (!__owns_)
+ __throw_system_error(EPERM, "unique_lock::unlock: not locked");
+ __m_->unlock();
+ __owns_ = false;
+}
+
+template <class _Mutex>
+inline
+void
+swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) {__x.swap(__y);}
+
+struct cv_status
+{
+ enum _ {
+ no_timeout,
+ timeout
+ };
+
+ _ __v_;
+
+ cv_status(_ __v) : __v_(__v) {}
+ operator int() const {return __v_;}
+
+};
+
+class condition_variable
+{
+ pthread_cond_t __cv_;
+public:
+ condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
+ ~condition_variable();
+
+private:
+ condition_variable(const condition_variable&); // = delete;
+ condition_variable& operator=(const condition_variable&); // = delete;
+
+public:
+ void notify_one();
+ void notify_all();
+
+ void wait(unique_lock<mutex>& __lk);
+ template <class _Predicate>
+ void wait(unique_lock<mutex>& __lk, _Predicate __pred);
+
+ template <class _Duration>
+ cv_status
+ wait_until(unique_lock<mutex>& __lk,
+ const chrono::time_point<chrono::system_clock, _Duration>& __t);
+
+ template <class _Clock, class _Duration>
+ cv_status
+ wait_until(unique_lock<mutex>& __lk,
+ const chrono::time_point<_Clock, _Duration>& __t);
+
+ template <class _Clock, class _Duration, class _Predicate>
+ bool
+ wait_until(unique_lock<mutex>& __lk,
+ const chrono::time_point<_Clock, _Duration>& __t,
+ _Predicate __pred);
+
+ template <class _Rep, class _Period>
+ cv_status
+ wait_for(unique_lock<mutex>& __lk,
+ const chrono::duration<_Rep, _Period>& __d);
+
+ template <class _Rep, class _Period, class _Predicate>
+ bool
+ wait_for(unique_lock<mutex>& __lk,
+ const chrono::duration<_Rep, _Period>& __d,
+ _Predicate __pred);
+
+ typedef pthread_cond_t* native_handle_type;
+ native_handle_type native_handle() {return &__cv_;}
+
+private:
+ void __do_timed_wait(unique_lock<mutex>& __lk,
+ chrono::time_point<chrono::system_clock, chrono::nanoseconds>);
+};
+
+template <class _To, class _Rep, class _Period>
+inline
+typename enable_if
+<
+ chrono::__is_duration<_To>::value,
+ _To
+>::type
+__ceil(chrono::duration<_Rep, _Period> __d)
+{
+ using namespace chrono;
+ _To __r = duration_cast<_To>(__d);
+ if (__r < __d)
+ ++__r;
+ return __r;
+}
+
+template <class _Predicate>
+void
+condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
+{
+ while (!__pred())
+ wait(__lk);
+}
+
+template <class _Duration>
+cv_status
+condition_variable::wait_until(unique_lock<mutex>& __lk,
+ const chrono::time_point<chrono::system_clock, _Duration>& __t)
+{
+ using namespace chrono;
+ typedef time_point<system_clock, nanoseconds> __nano_sys_tmpt;
+ __do_timed_wait(__lk,
+ __nano_sys_tmpt(__ceil<nanoseconds>(__t.time_since_epoch())));
+ return system_clock::now() < __t ? cv_status::no_timeout :
+ cv_status::timeout;
+}
+
+template <class _Clock, class _Duration>
+cv_status
+condition_variable::wait_until(unique_lock<mutex>& __lk,
+ const chrono::time_point<_Clock, _Duration>& __t)
+{
+ using namespace chrono;
+ system_clock::time_point __s_now = system_clock::now();
+ typename _Clock::time_point __c_now = _Clock::now();
+ __do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__t - __c_now));
+ return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;
+}
+
+template <class _Clock, class _Duration, class _Predicate>
+bool
+condition_variable::wait_until(unique_lock<mutex>& __lk,
+ const chrono::time_point<_Clock, _Duration>& __t,
+ _Predicate __pred)
+{
+ while (!__pred())
+ {
+ if (wait_until(__lk, __t) == cv_status::timeout)
+ return __pred();
+ }
+ return true;
+}
+
+template <class _Rep, class _Period>
+cv_status
+condition_variable::wait_for(unique_lock<mutex>& __lk,
+ const chrono::duration<_Rep, _Period>& __d)
+{
+ using namespace chrono;
+ system_clock::time_point __s_now = system_clock::now();
+ monotonic_clock::time_point __c_now = monotonic_clock::now();
+ __do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
+ return monotonic_clock::now() - __c_now < __d ? cv_status::no_timeout :
+ cv_status::timeout;
+}
+
+template <class _Rep, class _Period, class _Predicate>
+inline
+bool
+condition_variable::wait_for(unique_lock<mutex>& __lk,
+ const chrono::duration<_Rep, _Period>& __d,
+ _Predicate __pred)
+{
+ return wait_until(__lk, chrono::monotonic_clock::now() + __d,
+ _STD::move(__pred));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MUTEX_BASE