Refactored pthread usage in libcxx

[espositofulvio]

Summary

This patch is a refactoring of pthread usage in libcxx to support/pthread in order to ease porting to Windows.

[jroelofs]

include/__mutex_base

19

I think it might make sense to create a file: <support/mutex.h> where the contents are just:

#ifndef _WIN32
#include <support/pthread/mutex.hpp>
#endif

And include that file here so that the platform decision of "which mutex implementation should we use" doesn't have these #ifndef guards spread everywhere.

Maybe you could also add some defines & guards to enforce the idea that <support/pthread/mutex.hpp> is never included directly, but rather only via <support/mutex.h>.

Same should go for thread.hpp, too.

[theraven]

include/__mutex_base

246

Does this change the ABI for a mutex on *NIX platforms? We can't change the class layout for existing platforms (though we can indirect things via typedefs).

include/mutex

182

As above, there should probably be in a cross-platform support file that includes these. In particular, not-win32 is not the correct condition for uses-pthreads. We should probably have something in __config that determines the thread library to use. It would be quite nice to have a C11 thread back end, for example (though most implementations currently wrap pthreads).

269

I didn't realise this idiocy made it into C++11, I thought it was confined to C11. Locking a mutex using anything other than time intervals on the monotonic time source is a great way of producing non-working programs. We should probably warn if anyone actually calls this...

[espositofulvio]

include/__mutex_base

19

A very good idea indeed. I'll make the change and update the patch.

246

My hunch is that it doesn't, std::condition_variable has no data member now and the first base class (__libcxx_support::condition_variable) contains only pthread_cond_t which will be effectively laid out at the starting address of the object, as it was previously for std::condition_variable,. I will check this out later in the evening though.

include/mutex

182

In this case having a series of #ifdef FreeBSD (or _WIN32, etc.) doesn't quite cut it as we want to be able to select C11 or pthread on most of them and on Windows one day it might even be C11, pthread or the win32 api. I guess the alternative is to provide a cmake variable that default to something different on each platform?

[theraven]

include/__mutex_base

246

I *think* that it's correct, but it's worth compiling a program that has one compilation unit using the old header and another using the new one and check that it's able to interoperate correctly.

Also check whether this depends on the implementation of the condition variable. On FreeBSD, the pthread types are all pointers (currently - we're going to have some painful ABI breakage at some point when we move them to being something that can live in shared memory). In glibc, they're structures. I don't think that you'll end up with different padding in the ABI from wrapping them in a class, but it's worth checking.

include/mutex

182

We'll probably end up with a set of #ifdef FreeBSD (or whatever) things, but making sure that they're all in a single file will help. If you're doing bring-up of a new platform, just having to set #define LIBCXX_THREAD_API LIBCXX_PTHREAD, or LIBCXX_C11_THREADS, (or Haiku threads, or whatever) in one place makes life a bit easier. One of the annoyances with trying to port asan was that the original developers used #ifdef APPLE__ to mean 'is not Linux' and 'is Darwin' in various places, so we needed to look at every single change and determine whether they were shared between multiple non-GNU platforms or whether they were specific to OS X / iOS.

[espositofulvio]

include/__mutex_base

246

it's worth compiling a program that has one compilation unit using the old header and another using the new one and check that it's able to interoperate correctly

Unfortunately this isn't going to work, some simbols are now defined in __libcxx_support and not in std (they are just made available through using), so an object file that includes the old header won't link against the new library (unreferenced symbols). The alternative is to create inline forwarding methods.

[theraven]

include/__mutex_base

246

That's going to need some more refactoring then. Breaking the public ABI of libc++ would be a show-stopper.

[espositofulvio]

include/__mutex_base

246

Yes, that's what I thought. In this case it's better to create a new diff and abandon this one or just update it?

[jroelofs]

better to just update this one... you've got our attention here review-wise.

[espositofulvio]

To avoid breaking public api and ABI, the os abstraction layer is made up of typedefs for pthread types + plain functions that are called from the std:: stuff.
The recursive mutex layer is identical for pthread to the mutex layer because pthread internally select locking implementation depending on the mutex attributes, but we need both because on Windows the recursive stuff must be implemented with a counter.

[theraven]

This version looks much better (well, the previous one is cleaner, but this one looks like it shouldn't break the ABI - did you test this? It looks like it should work, but I've not actually tried it).

include/__config

742 ↗

(On Diff #31593)

#ifdef unix will catch most of these (for some reason, not OS X, even though it's the only one that actually is certified as UNIX...)

[espositofulvio]

In D11781#219859, @theraven wrote:

This version looks much better (well, the previous one is cleaner, but this one looks like it shouldn't break the ABI - did you test this? It looks like it should work, but I've not actually tried it).

I tried it on Linux, using the example from http://en.cppreference.com/w/cpp/thread/condition_variable, but splitting the main and the worker function in two different translation units and compiling one with the libc++ coming from ArchLinux and the other with my branch, and then linking both with the new lib. I don't have freebsd installed though, I can set up another virtual machine but I never used FreeBsd so I don't know how easy is to install and set up.

[espositofulvio]

include/__config

742 ↗

(On Diff #31593)

I didn't know that and I'm not sure I've included all the supported platforms (in include/__config there are definitions for __ sun __ and __ CloudABI __ which I know very little about). Is there somewhere a list of supported platforms?

[ed]

include/__config

742 ↗

(On Diff #31593)

CloudABI has pthreads, but it does not have unix defined. Both FreeBSD and CloudABI also support C11 <threads.h>.

If you're going to stick to the code you have right now, be sure to add defined(__CloudABI__) to that list of operating systems.

The POSIX way of testing whether pthreads is available is:

#include <unistd.h>
#if _POSIX_THREADS > 0
...
#endif

See: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/unistd.h.html

[ed]

A general note I have regarding this change:

Now that we're introducing separate implementations for mutexes and condition variables, could we also consider letting shared_mutex and friends simply use pthread_rwlock_*()? We currently have it implemented as a wrapper on top of mutexes and condition variables, but the downside of this approach is that it potentially has more overhead, but also works around priority inheritance if supported by the implementation.

[theraven]

It would be nice to use rwlocks, but that's an ABI-breaking change. We'd need to bump the .so version and other annoyances. Definitely something I'd be in favour of seeing hidden behind some #ifdefs (and enabled for FreeBSD 11 and probably for the libc++ in packages), but it's beyond the scope of this set of changes.

[espositofulvio]

include/__config

742 ↗

(On Diff #31593)

Unfortunately I think the POSIX way would fail on any system that hasn't unistd.h (Windows), so I think I'll stick with the list and add the missing ones.

742 ↗

(On Diff #31593)

It looks like unix is not defined on Linux, but it has __unix. I think it's safer to stick to the list.

[espositofulvio]

Added CloudABI to the list of platform using pthread

[jroelofs]

include/__config

742 ↗

(On Diff #31716)

@espositofulvio: @ed meant this:

#ifndef _WIN32
#  include <unistd.h>
#  if _POSIX_THREADS > 0
...
#  endif
#endif

Which is the correct way to test for this.

[jroelofs]

include/__config

742 ↗

(On Diff #31716)

That being said, there have been discussions before about whether or not we should #include <unistd.h> in <__config>, with the conclusion being that we shouldn't.

It would be better if this were a CMake configure-time check that sets _LIBCPP_THREAD_API, rather than these build-time guards.

[espositofulvio]

include/__config

742 ↗

(On Diff #31716)

Tried adding that as configure time checks, but then libcxxabi fails to compile because of the guard in __config to check that _LIBCPP_THREAD_API has beed defined when _LIBCPP_HAS_NO_THREADS is not.

As a side note: Is Windows the only OS which hasn't got unistd.h?

[jroelofs]

include/__config

742 ↗

(On Diff #31716)

Tried adding that as configure time checks...

Can you put the patch for that up on gist.github.com, or a pastebin?... I'll take a look.

As a side note: Is Windows the only OS which hasn't got unistd.h?

For the platforms libcxx currently builds on, yes.

[espositofulvio]

include/__config

742 ↗

(On Diff #31716)

Can you put the patch for that up on gist.github.com, or a pastebin?... I'll take a look.

It's here https://gist.github.com/espositofulvio/eac2fb08acf2e430c516

[theraven]

include/__config

742 ↗

(On Diff #31716)

I'm sorry to have triggered this bikeshed. Given that, of the currently supported platforms, Windows is the only one where we want to use threads but don't want to use PTHREADS, I think it's fine to have this check be !WIN32. The important thing is having the check *in one place* so that the person who wants to add the *second* non-pthread threading implementation doesn't have a load of different places to look: they can just change it in __config and then chase all of the compile failures.

[espositofulvio]

include/__config

742 ↗

(On Diff #31716)

Given that it's something I suggested in a comment on the first revision, I was happy to try it out. It was also a quick change. Unfortunately it brakes libcxxabi build (at least the way I've done it), so I'm happy to make the change if @jroelofs finds another way

[jroelofs]

include/__config

742 ↗

(On Diff #31716)

I meant something like this: https://gist.github.com/jroelofs/279cb2639ad910b953d2

... which doesn't quite work yet, but should give you the idea. I don't know how to get CMake to treat ${CMAKE_BINARY_DIR}/include/c++/v1 as the includes directory instead of ${CMAKE_CURRENT_SOURCE_DIR}/../include. Maybe @EricWF can help with that?

Basically the idea is that we have cmake create a config_site header which config includes. This new header would then have the definitions for these kinds of configure-time decisions.

[mclow.lists]

I agree with @jroelofs that we don't want to #include <unistd.h> in <__config>

[jroelofs]

include/__config

742 ↗

(On Diff #31716)

I tinkered around with this a bit more, and got it to work. I've updated the gist to reflect that.

To simplify things for @espositofulvio, I'm going to split out the __config_site part of this change into its own review.

[espositofulvio]

include/__config

742 ↗

(On Diff #31716)

I was working on your idea and make it to compile as well, I'm just re-running the test suite to be 100% sure. Looking at your diff it seems there's a difference in the path.

${CMAKE_BINARY_DIR}/include/c++/v1/__config_site

the above doesn't work for me, I've used:

${CMAKE_CURRENT_SOURCE_DIR}/include/__config_site

Should I update my review?

[espositofulvio]

Thread library selection is done at configure time by CMake now.

[jroelofs]

include/__config

744 ↗

(On Diff #31874)

The reason to use CMAKE_BINARY_DIR over CMAKE_CURRENT_SOURCE_DIR as the location for this build product is so that the source directory doesn't get polluted by builds.

Unfortunately that means that both libcxx and libcxxabi need to be pointed at the headers in the build directory, and not the ones from the source directory.

I do have a pair of patches for this, which I'll post shortly.

[jroelofs]

include/__config

744 ↗

(On Diff #31874)

See: D11963 and D11964

[mclow.lists]

How does this change interact with D11963 ?

[espositofulvio]

In D11781#222452, @mclow.lists wrote:

How does this change interact with D11963 ?

The difference between this and @jroelofs's one is that this copy the __config_site in the source directory which makes everything compile fine without having to point libcxx and libcxxabi to the build directory. Jonathan thinks it's better not to pollute the source dir so he made those patches.

[joerg]

This feels a bit like a regression. Before, libc++ works fine by just pointing into the include directory.

[espositofulvio]

In D11781#222572, @joerg wrote:

This feels a bit like a regression. Before, libc++ works fine by just pointing into the include directory.

With my change it still is fine pointing at the include directory. But as I said, Jonathan feels it's not right to have the configure generated include file in the source directory hence he's proposing a separate patch to address that.

[EricWF]

This patch has a long way to go but it has also come a long way. Here are a couple of problems I see with it.

1. There are still plenty of ABI breaks. I'll try and point them all out.
2. This patch adds a lot of headers. libc++ has historically tried to keep the number of headers to a minimum for the reason that filesystem operations are expensive and its cheaper to include a few big headers as opposed to many small ones.
3. There where some subtle static initialization changes. However they may have been fixed.

I'll do a more through review soon.

include/mutex

534

This looks like an ABI break to me.

[EricWF]

Added more inline comments.

include/__mutex_base

36

Why was the cast insignificant?

275

Why was the cast insignificant?

include/thread

412

I'm 99% this is an ABI break. Don't inline this function and make the change within the definition

include/type_traits

222 ↗

(On Diff #31874)

This change seems to have snuck in.

src/algorithm.cpp

51

I think this prevents __rs_mut from being initialized during constant initialization. (http://en.cppreference.com/w/cpp/language/constant_initialization)

src/memory.cpp

130

I have no idea what is going on here. Do you understand what this code was trying to do?

[espositofulvio]

In D11781#227446, @EricWF wrote:

This patch has a long way to go but it has also come a long way. Here are a couple of problems I see with it.

2. This patch adds a lot of headers. libc++ has historically tried to keep the number of headers to a minimum for the reason that filesystem operations are expensive and its cheaper to include a few big headers as opposed to many small ones.

I know but it was a request from reviewers so that platform specific decision were localized. I can obviously merge all of the support/mutex.h, support/thread.h and support/condition_variable.h in a single support/thread.h if that's the case.

include/type_traits

222 ↗

(On Diff #31874)

Yes, and actually I'm not sure how it did as it's something I haven't touched. Unfortunately I don't have time before later next week to address all the issues.

src/algorithm.cpp

51

I think this falls in the second case:

Static or thread-local object of class type that is initialized by a constructor call, if the constructor is constexpr and all constructor arguments (including implicit conversions) are constant expressions, and if the initializers in the constructor's initializer list and the brace-or-equal initializers of the class memebers only contain constant expressions.

but I was actually relying on the fact that we have constexpr, which now I understand could not be the case.

src/memory.cpp

130

My understanding is that this is trying to init the array during constant initialization and later relying on the internal layout of std::mutex to be equal to a pthread_mutex_t to cast it and use it as a std::mutex.

from cppreference:
Static or thread-local object (not necessarily of class type), that is not initialized by a constructor call, if the object is value-initialized or if every expression in its initializer is a constant expression.

Again, I think my change should be ok as long as constexpr is available, but I could be wrong.

[espositofulvio]

include/__mutex_base

36

The cast was significant, but it's not needed anymore. PTHREAD_MUTEX_INITIALIZER can be only used in initialization expression, not regular assignment and that's why there was the cast. But now I'm assigning an already-initialized mutex:

_LIBCPP_CONSTEXPR pthread_mutex_t __os_mutex_init = PTHREAD_MUTEX_INITIALIZER;

thus the cast is not needed anymore.

[EricWF]

In D11781#227606, @espositofulvio wrote:

In D11781#227446, @EricWF wrote:

This patch has a long way to go but it has also come a long way. Here are a couple of problems I see with it.

2. This patch adds a lot of headers. libc++ has historically tried to keep the number of headers to a minimum for the reason that filesystem operations are expensive and its cheaper to include a few big headers as opposed to many small ones.

I know but it was a request from reviewers so that platform specific decision were localized. I can obviously merge all of the support/mutex.h, support/thread.h and support/condition_variable.h in a single support/thread.h if that's the case.

Sorry for giving conflicting feedback. I'm happy with multiple headers for now. We can always address it later.

src/algorithm.cpp

51

The top of the documentation it shows the syntax that is required to get constant initialization. The initialization must have the form T obj = <initalizer>. I would be fine relying on constexpr though.

[espositofulvio]

• Addressed possible ABI breaks
• Reverted to not using a __config_file as @jroelofs has two separate patches for that

[rmaprath]

Hi, could I know the status of this? I'd like to push this forward.

@espositofulvio: Are you working on this? (just checking since this has gone stale for a while). @EricWF: I can create a separate diff for further review if this one is too cluttered.

Cheers,

/ Asiri

[EricWF]

I would like to see this patch without the support/pthread/*.cpp files. There are a couple of reasons for this.

1. The symbols in those files are private to the dylib, but they are declared in the headers and given external visibility.
2. Those symbols frequently use std::chrono types in their interface. This creates a layering violating between the main STL and the support headers.
3. Moving the implementations of those functions now creates a bunch of noise in an already noisy patch. Keep the implementations in place for now.

Those changes can be re-added in a follow up patch.

Please combine all everything in support into a single file in the top level directory called __thread_support (Or similar, the name really doesn't matter but it should start with two underscores). Libc++ keeps the number of private headers is kept to a minimum and only introduces a new one when it needs to break a cycle or factor out code used in two places.

Overall this is looking good. Have you implemented a support layer for windows at all? If so I would be curious to see it, I would like to get a better idea of the end goal.

include/support/pthread/condition_variable.h

54 ↗

(On Diff #34104)

This is an internal function. It shouldn't be declared in these headers.

include/support/pthread/mutex.h

27 ↗

(On Diff #34104)

I think with would work for C++11 onward but unfortunately the mutex internals need to support C++03. For this reason we have to use a macro to ensure the initializer is constexpr.

59 ↗

(On Diff #34104)

This is an internal function and shouldn't be declared in the headers.

62 ↗

(On Diff #34104)

Shouldn't these functions take __os_recursive_mutex* types?

85 ↗

(On Diff #34104)

This is an internal function and shouldn't be declared in the headers.

include/support/pthread/thread.h

60 ↗

(On Diff #34104)

res needs to be an int, not a bool.

67 ↗

(On Diff #34104)

This function seems superfluous and introduces a dependency on IO streams. Get rid of it.

114 ↗

(On Diff #34104)

This is an internal function and shouldn't be declared in the headers.

include/thread

127–128

This now call's pthread_equal, across a library boundary, where it didn't before. That seems like a pessimization.

127–128

Same as above.

127–128

As mentioned elsewhere just do this operation inline. No need for an extra function.

254–255

Typo _Gp should be _Fp.

[rmaprath]

Hi Eric, Thanks for the comments!

I'll wait a bit for @espositofulvio in case if he wants to push this, otherwise I'll create a new diff with the suggested changes.

For us (ARM), a threads porting layer is important on several RTOSes (where a full-blown pthreads implementations is not available). I will see if I can publish one of those porting layer implementations, but perhaps a windows porting layer is more interesting to the community, in which case I'll look into hacking one up (unless of course, if @espositofulvio has already got one).

Cheers,

/ Asiri

[theraven]

In D11781#403335, @rmaprath wrote:

For us (ARM), a threads porting layer is important on several RTOSes (where a full-blown pthreads implementations is not available). I will see if I can publish one of those porting layer implementations, but perhaps a windows porting layer is more interesting to the community, in which case I'll look into hacking one up (unless of course, if @espositofulvio has already got one).

I'd be equally interested (and willing to review) an mbed implementation.

[rmaprath]

In D11781#403343, @theraven wrote:

In D11781#403335, @rmaprath wrote:

For us (ARM), a threads porting layer is important on several RTOSes (where a full-blown pthreads implementations is not available). I will see if I can publish one of those porting layer implementations, but perhaps a windows porting layer is more interesting to the community, in which case I'll look into hacking one up (unless of course, if @espositofulvio has already got one).

I'd be equally interested (and willing to review) an mbed implementation.

Thanks!

If you meant the mbed OS [1], I think it is still single-threaded (although that might change in the near future [2]). Most of our customers (of armclang) have proprietary RTOSes, but we might be able upstream a sample implementation (I'm thinking Keil RTX [3], but need to double check a few things), if it seems generally useful to the community.

Cheers,

/ Asiri

[1] https://www.mbed.com/
[2] https://www.mbed.com/en/development/software/mbed-os/ ("...we intend to re-introduce it in 2016")
[3] http://www.keil.com/rl-arm/kernel.asp

[espositofulvio]

In D11781#400968, @rmaprath wrote:

Hi, could I know the status of this? I'd like to push this forward.

@espositofulvio: Are you working on this? (just checking since this has gone stale for a while). @EricWF: I can create a separate diff for further review if this one is too cluttered.

Unfortunately I don't have much spare time at the moment, and that being something I was doing to learn about libc++ and not something I needed, it got sidetracked. So go ahead with your work.
Best regards,
Fulvio

[rmaprath]

In D11781#403378, @espositofulvio wrote:

In D11781#400968, @rmaprath wrote:

Hi, could I know the status of this? I'd like to push this forward.

@espositofulvio: Are you working on this? (just checking since this has gone stale for a while). @EricWF: I can create a separate diff for further review if this one is too cluttered.

Unfortunately I don't have much spare time at the moment, and that being something I was doing to learn about libc++ and not something I needed, it got sidetracked. So go ahead with your work.
Best regards,
Fulvio

I think you've done all the difficult bits already :) I'll polish it up and address the remaining comments.

Thanks!!

/ Asiri

[rmaprath]

In D11781#403349, @rmaprath wrote:

In D11781#403343, @theraven wrote:

In D11781#403335, @rmaprath wrote:

For us (ARM), a threads porting layer is important on several RTOSes (where a full-blown pthreads implementations is not available). I will see if I can publish one of those porting layer implementations, but perhaps a windows porting layer is more interesting to the community, in which case I'll look into hacking one up (unless of course, if @espositofulvio has already got one).

I'd be equally interested (and willing to review) an mbed implementation.

Thanks!

If you meant the mbed OS [1], I think it is still single-threaded (although that might change in the near future [2]). Most of our customers (of armclang) have proprietary RTOSes, but we might be able upstream a sample implementation (I'm thinking Keil RTX [3], but need to double check a few things), if it seems generally useful to the community.

Cheers,

/ Asiri

[1] https://www.mbed.com/
[2] https://www.mbed.com/en/development/software/mbed-os/ ("...we intend to re-introduce it in 2016")
[3] http://www.keil.com/rl-arm/kernel.asp

I stand corrected, mbed already has an RTOS layer: https://developer.mbed.org/handbook/RTOS. I'm not very familiar with mbed (obviously). I will do some digging to see how difficult it would be to port libcxx to mbed (we already build libcxx for cortex-m bare-metal systems, so this shouldn't be that hard).

After reading through the past threads, providing a windows thread porting layer sounds like a useless thing, given that getting libcxx to build on windows itself is a rather large piece of work.

Cheers,

• Asiri

[rmaprath]

@espositofulvio: Thanks for the patch! :)

Committed as r268734.

[espositofulvio]

In D11781#423520, @rmaprath wrote:

@espositofulvio: Thanks for the patch! :)

Committed as r268734.

Glad to see you land the patch! Great work :)

[EricWF]

This revision is no longer relevant after. The __threading_support changes have applied changes similar to this.

include/__mutex_base

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MUTEX_BASE
 #define _LIBCPP___MUTEX_BASE
 
 #include <__config>
 #include <chrono>
 #include <system_error>
-#include <pthread.h>
+
+#ifndef _WIN32
+#include <support/pthread/mutex.hpp>
+#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
-class _LIBCPP_TYPE_VIS mutex
-{
-    pthread_mutex_t __m_;
-
-public:
-    _LIBCPP_INLINE_VISIBILITY
-#ifndef _LIBCPP_HAS_NO_CONSTEXPR
-     constexpr mutex() _NOEXCEPT : __m_(PTHREAD_MUTEX_INITIALIZER) {}
-#else
-     mutex() _NOEXCEPT {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
-#endif
-     ~mutex();
-
-private:
-    mutex(const mutex&);// = delete;
-    mutex& operator=(const mutex&);// = delete;
-
-public:
-    void lock();
-    bool try_lock() _NOEXCEPT;
-    void unlock() _NOEXCEPT;
-
-    typedef pthread_mutex_t* native_handle_type;
-    _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
-};
+using __libcxx_support::mutex;
 
 struct _LIBCPP_TYPE_VIS defer_lock_t {};
 struct _LIBCPP_TYPE_VIS try_to_lock_t {};
 struct _LIBCPP_TYPE_VIS adopt_lock_t {};
 
 #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MUTEX)
 
 extern const defer_lock_t  defer_lock;

 //enum class cv_status
 _LIBCPP_DECLARE_STRONG_ENUM(cv_status)
 {
     no_timeout,
     timeout
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(cv_status)
 
-class _LIBCPP_TYPE_VIS condition_variable
+class _LIBCPP_TYPE_VIS condition_variable : private __libcxx_support::condition_variable
 {
-    pthread_cond_t __cv_;
+    typedef __libcxx_support::condition_variable base;
 public:
     _LIBCPP_INLINE_VISIBILITY
-#ifndef _LIBCPP_HAS_NO_CONSTEXPR
-    constexpr condition_variable() : __cv_(PTHREAD_COND_INITIALIZER) {}
-#else
-    condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
-#endif
-    ~condition_variable();
+    condition_variable() {}
 
 private:
     condition_variable(const condition_variable&); // = delete;
     condition_variable& operator=(const condition_variable&); // = delete;
 
 public:
-    void notify_one() _NOEXCEPT;
-    void notify_all() _NOEXCEPT;
+    typedef base::native_handle_type native_handle_type;
+    using base::notify_one;
+    using base::notify_all;
+    using base::native_handle;
     
     void wait(unique_lock<mutex>& __lk) _NOEXCEPT;
     template <class _Predicate>
         void wait(unique_lock<mutex>& __lk, _Predicate __pred);
 
     template <class _Clock, class _Duration>
         cv_status
         wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<_Clock, _Duration>& __t);
template <class _Rep, class _Period>
                  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;
-    _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
 
 private:
     void __do_timed_wait(unique_lock<mutex>& __lk,
        chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;
 };
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 template <class _To, class _Rep, class _Period>

include/mutex

 
 #include <__config>
 #include <__mutex_base>
 #include <functional>
 #include <memory>
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 #include <tuple>
 #endif
-#include <sched.h>
+#ifndef _WIN32
+#include <support/pthread/mutex.hpp>
+#include <support/pthread/thread.hpp>
+#endif
 
 #include <__undef_min_max>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
-class _LIBCPP_TYPE_VIS recursive_mutex
-{
-    pthread_mutex_t __m_;
-
-public:
-     recursive_mutex();
-     ~recursive_mutex();
-
-private:
-    recursive_mutex(const recursive_mutex&); // = delete;
-    recursive_mutex& operator=(const recursive_mutex&); // = delete;
-
-public:
-    void lock();
-    bool try_lock() _NOEXCEPT;
-    void unlock()  _NOEXCEPT;
-
-    typedef pthread_mutex_t* native_handle_type;
-    _LIBCPP_INLINE_VISIBILITY
-    native_handle_type native_handle() {return &__m_;}
-};
+using __libcxx_support::recursive_mutex;
 
 class _LIBCPP_TYPE_VIS timed_mutex
 {
     mutex              __m_;
     condition_variable __cv_;
     bool               __locked_;
 public:
      timed_mutex();
if (!__locked_)
         __locked_ = true;
         return true;
     }
     return false;
 }
 
 class _LIBCPP_TYPE_VIS recursive_timed_mutex
 {
-    mutex              __m_;
-    condition_variable __cv_;
-    size_t             __count_;
-    pthread_t          __id_;
+    mutex                         __m_;
+    condition_variable            __cv_;
+    size_t                        __count_;
+    __libcxx_support::__thread_id __id_;
 public:
      recursive_timed_mutex();
      ~recursive_timed_mutex();
 
 private:
     recursive_timed_mutex(const recursive_timed_mutex&); // = delete;
     recursive_timed_mutex& operator=(const recursive_timed_mutex&); // = delete;
 
 public:
     void lock();
     bool try_lock() _NOEXCEPT;
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
             {return try_lock_until(chrono::steady_clock::now() + __d);}
     template <class _Clock, class _Duration>
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
 bool
 recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {
     using namespace chrono;
-    pthread_t __id = pthread_self();
+    __libcxx_support::__thread_id __id = __libcxx_support::get_id();
     unique_lock<mutex> lk(__m_);
-    if (pthread_equal(__id, __id_))
+    if (__id == __id_)
     {
         if (__count_ == numeric_limits<size_t>::max())
             return false;
         ++__count_;
         return true;
     }
     bool no_timeout = _Clock::now() < __t;
     while (no_timeout && __count_ != 0)
while (true)
         {
             unique_lock<_L0> __u0(__l0);
             if (__l1.try_lock())
             {
                 __u0.release();
                 break;
             }
         }
-        sched_yield();
+        __libcxx_support::yield();
         {
             unique_lock<_L1> __u1(__l1);
             if (__l0.try_lock())
             {
                 __u1.release();
                 break;
             }
         }
-        sched_yield();
+        __libcxx_support::yield();
     }
 }
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <class _L0, class _L1, class _L2, class ..._L3>
 void
 __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 {
     while (true)
     {
         switch (__i)
         {
         case 0:
             {
                 unique_lock<_L0> __u0(__l0);
                 __i = try_lock(__l1, __l2, __l3...);
                 if (__i == -1)
                 {
                     __u0.release();
                     return;
                 }
             }
             ++__i;
-            sched_yield();
+            __libcxx_support::yield();
             break;
         case 1:
             {
                 unique_lock<_L1> __u1(__l1);
                 __i = try_lock(__l2, __l3..., __l0);
                 if (__i == -1)
                 {
                     __u1.release();
                     return;
                 }
             }
             if (__i == sizeof...(_L3) + 1)
                 __i = 0;
             else
                 __i += 2;
-            sched_yield();
+            __libcxx_support::yield();
             break;
         default:
             __lock_first(__i - 2, __l2, __l3..., __l0, __l1);
             return;
         }
     }
 }
 

 template <class _Fp>
 void
 __call_once_proxy(void* __vp)
 {
     __call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);
     (*__p)();
 }
 
-_LIBCPP_FUNC_VIS void __call_once(volatile unsigned long&, void*, void(*)(void*));
+using __libcxx_support::__call_once;
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template<class _Callable, class... _Args>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
 {

include/support/pthread/mutex.hpp

+// -*- C++ -*-
+//===---------------------- support/pthread/mutex.hpp ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_PTHREAD_MUTEX_HPP
+#define _LIBCPP_SUPPORT_PTHREAD_MUTEX_HPP
+
+#include <chrono>
+#include <pthread.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __libcxx_support
+{
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+class _LIBCPP_TYPE_VIS mutex
+{
+    pthread_mutex_t __m_;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+#ifndef _LIBCPP_HAS_NO_CONSTEXPR
+     constexpr mutex() _NOEXCEPT : __m_(PTHREAD_MUTEX_INITIALIZER) {}
+#else
+     mutex() _NOEXCEPT {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
+#endif
+     ~mutex();
+
+private:
+    mutex(const mutex&);// = delete;
+    mutex& operator=(const mutex&);// = delete;
+
+public:
+    void lock();
+    bool try_lock() _NOEXCEPT;
+    void unlock() _NOEXCEPT;
+
+    typedef pthread_mutex_t* native_handle_type;
+    _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
+};
+
+
+class _LIBCPP_TYPE_VIS condition_variable
+{
+    pthread_cond_t __cv_;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+#ifndef _LIBCPP_HAS_NO_CONSTEXPR
+    constexpr condition_variable() : __cv_(PTHREAD_COND_INITIALIZER) {}
+#else
+    condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
+#endif
+    ~condition_variable();
+
+private:
+    condition_variable(const condition_variable&); // = delete;
+    condition_variable& operator=(const condition_variable&); // = delete;
+
+public:
+    void notify_one() _NOEXCEPT;
+    void notify_all() _NOEXCEPT;
+    
+    typedef pthread_cond_t* native_handle_type;
+    _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
+
+protected:
+    void __wait(pthread_mutex_t* __lk) _NOEXCEPT;
+    void __do_timed_wait(pthread_mutex_t* __lk,
+        _VSTD::chrono::time_point<_VSTD::chrono::system_clock, _VSTD::chrono::nanoseconds> __tp) _NOEXCEPT;
+};
+
+
+class _LIBCPP_TYPE_VIS recursive_mutex
+{
+    pthread_mutex_t __m_;
+
+public:
+     recursive_mutex();
+     ~recursive_mutex();
+
+private:
+    recursive_mutex(const recursive_mutex&); // = delete;
+    recursive_mutex& operator=(const recursive_mutex&); // = delete;
+
+public:
+    void lock();
+    bool try_lock() _NOEXCEPT;
+    void unlock()  _NOEXCEPT;
+
+    typedef pthread_mutex_t* native_handle_type;
+    _LIBCPP_INLINE_VISIBILITY
+    native_handle_type native_handle() {return &__m_;}
+};
+
+
+_LIBCPP_FUNC_VIS void __call_once(volatile unsigned long&, void*, void(*)(void*));
+
+#endif
+
+} // namespace __libcxx_support
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SUPPORT_PTHREAD_MUTEX_HPP

include/support/pthread/thread.hpp

+// -*- C++ -*-
+//===---------------------- support/pthread/thread.hpp --------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_PTHREAD_THREAD_HPP
+#define _LIBCPP_SUPPORT_PTHREAD_THREAD_HPP
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#include <system_error>
+#include <functional>
+#include <pthread.h>
+#include <sched.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __libcxx_support
+{
+
+template <class _Tp>
+class __thread_specific_ptr
+{
+    pthread_key_t __key_;
+
+    __thread_specific_ptr(const __thread_specific_ptr&);
+    __thread_specific_ptr& operator=(const __thread_specific_ptr&);
+
+    static void __at_thread_exit(void*);
+public:
+    typedef _Tp* pointer;
+
+    __thread_specific_ptr();
+    ~__thread_specific_ptr();
+
+    _LIBCPP_INLINE_VISIBILITY
+    pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
+    _LIBCPP_INLINE_VISIBILITY
+    pointer operator*() const {return *get();}
+    _LIBCPP_INLINE_VISIBILITY
+    pointer operator->() const {return get();}
+    pointer release();
+    void reset(pointer __p = nullptr);
+};
+
+template <class _Tp>
+void
+__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
+{
+    delete static_cast<pointer>(__p);
+}
+
+template <class _Tp>
+__thread_specific_ptr<_Tp>::__thread_specific_ptr()
+{
+    int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    if (__ec)
+        throw system_error(error_code(__ec, system_category()),
+                           "__thread_specific_ptr construction failed");
+#endif
+}
+
+template <class _Tp>
+__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
+{
+    pthread_key_delete(__key_);
+}
+
+template <class _Tp>
+typename __thread_specific_ptr<_Tp>::pointer
+__thread_specific_ptr<_Tp>::release()
+{
+    pointer __p = get();
+    pthread_setspecific(__key_, 0);
+    return __p;
+}
+
+template <class _Tp>
+void
+__thread_specific_ptr<_Tp>::reset(pointer __p)
+{
+    pointer __p_old = get();
+    pthread_setspecific(__key_, __p);
+    delete __p_old;
+}
+
+class _LIBCPP_TYPE_VIS_ONLY __thread_id;
+
+inline _LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
+
+class _LIBCPP_TYPE_VIS_ONLY __thread_id
+{
+    // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
+    // NULL is the no-thread value on Darwin.  Someone needs to check
+    // on other platforms.  We assume 0 works everywhere for now.
+    pthread_t __id_;
+
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    __thread_id() _NOEXCEPT : __id_(0) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void reset() { __id_ = 0; }
+
+    friend _LIBCPP_INLINE_VISIBILITY
+        bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
+        {return __x.__id_ == __y.__id_;}
+    friend _LIBCPP_INLINE_VISIBILITY
+        bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
+        {return !(__x == __y);}
+    friend _LIBCPP_INLINE_VISIBILITY
+        bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
+        {return __x.__id_ < __y.__id_;}
+    friend _LIBCPP_INLINE_VISIBILITY
+        bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
+        {return !(__y < __x);}
+    friend _LIBCPP_INLINE_VISIBILITY
+        bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT
+        {return   __y < __x ;}
+    friend _LIBCPP_INLINE_VISIBILITY
+        bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT
+        {return !(__x < __y);}
+
+    template<class _CharT, class _Traits>
+    friend
+    _LIBCPP_INLINE_VISIBILITY
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
+        {return __os << __id.__id_;}
+
+private:
+    _LIBCPP_INLINE_VISIBILITY
+    __thread_id(pthread_t __id) : __id_(__id) {}
+
+    friend __thread_id get_id() _NOEXCEPT;
+    friend class _LIBCPP_TYPE_VIS thread;
+    friend struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
+};
+
+inline _LIBCPP_INLINE_VISIBILITY
+__thread_id
+get_id() _NOEXCEPT
+{
+    return pthread_self();
+}
+
+
+inline _LIBCPP_INLINE_VISIBILITY
+void yield() _NOEXCEPT
+{
+    sched_yield();
+}
+
+class _LIBCPP_TYPE_VIS thread
+{
+protected:
+    pthread_t __t_;
+
+    template<class _Fp, class _Args>
+    void start_thread(_Fp&& f, _Args&& __p);
+public:
+    typedef __thread_id id;
+    typedef pthread_t native_handle_type;
+
+    _LIBCPP_INLINE_VISIBILITY
+    thread() _NOEXCEPT : __t_(0) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool joinable() const _NOEXCEPT {return __t_ != 0;}
+    void join();
+    void detach();
+    _LIBCPP_INLINE_VISIBILITY
+    id get_id() const _NOEXCEPT {return __t_;}
+    _LIBCPP_INLINE_VISIBILITY
+    native_handle_type native_handle() _NOEXCEPT {return __t_;}
+
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
+    thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;}
+    thread& operator=(thread&& __t) _NOEXCEPT;
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+};
+
+
+
+template <class _Fp, class _Args>
+void thread::start_thread(_Fp&& __f, _Args&& __p)
+{
+    int __ec = pthread_create(&__t_, 0, __f, __p.get());
+    if (__ec == 0)
+        __p.release();
+    else
+        __throw_system_error(__ec, "thread constructor failed");
+}
+
+
+
+} // __libcxx_support
+
+template<>
+struct _LIBCPP_TYPE_VIS_ONLY hash<__libcxx_support::__thread_id>
+    : public unary_function<__libcxx_support::__thread_id, size_t>
+{
+    _LIBCPP_INLINE_VISIBILITY
+    size_t operator()(__libcxx_support::__thread_id __v) const
+    {
+        return hash<pthread_t>()(__v.__id_);
+    }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SUPPORT_PTHREAD_THREAD_HPP

include/thread

 #include <functional>
 #include <memory>
 #include <system_error>
 #include <chrono>
 #include <__mutex_base>
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 #include <tuple>
 #endif
-#include <pthread.h>
-#include <sched.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #define __STDCPP_THREADS__ __cplusplus
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 #error <thread> is not supported on this single threaded system
 #else // !_LIBCPP_HAS_NO_THREADS
 
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-class __thread_specific_ptr
-{
-    pthread_key_t __key_;
-
-    __thread_specific_ptr(const __thread_specific_ptr&);
-    __thread_specific_ptr& operator=(const __thread_specific_ptr&);
-
-    static void __at_thread_exit(void*);
-public:
-    typedef _Tp* pointer;
-
-    __thread_specific_ptr();
-    ~__thread_specific_ptr();
+#ifndef _WIN32
+#include <support/pthread/thread.hpp>
+#endif // _WIN32
 
-    _LIBCPP_INLINE_VISIBILITY
-    pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator*() const {return *get();}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return get();}
-    pointer release();
-    void reset(pointer __p = nullptr);
-};
-
-template <class _Tp>
-void
-__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
-{
-    delete static_cast<pointer>(__p);
-}
-
-template <class _Tp>
-__thread_specific_ptr<_Tp>::__thread_specific_ptr()
-{
-    int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    if (__ec)
-        throw system_error(error_code(__ec, system_category()),
-                           "__thread_specific_ptr construction failed");
-#endif
-}
-
-template <class _Tp>
-__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
-{
-    pthread_key_delete(__key_);
-}
-
-template <class _Tp>
-typename __thread_specific_ptr<_Tp>::pointer
-__thread_specific_ptr<_Tp>::release()
-{
-    pointer __p = get();
-    pthread_setspecific(__key_, 0);
-    return __p;
-}
-
-template <class _Tp>
-void
-__thread_specific_ptr<_Tp>::reset(pointer __p)
-{
-    pointer __p_old = get();
-    pthread_setspecific(__key_, __p);
-    delete __p_old;
-}
+_LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS thread;
-class _LIBCPP_TYPE_VIS __thread_id;
+using __libcxx_support::__thread_id;
 
 namespace this_thread
 {
 
-_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
+using __libcxx_support::get_id;
 
 }  // this_thread
 
-template<> struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
-
-class _LIBCPP_TYPE_VIS_ONLY __thread_id
-{
-    // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
-    // NULL is the no-thread value on Darwin.  Someone needs to check
-    // on other platforms.  We assume 0 works everywhere for now.
-    pthread_t __id_;
-
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    __thread_id() _NOEXCEPT : __id_(0) {}
-
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
-        {return __x.__id_ == __y.__id_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
-        {return !(__x == __y);}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
-        {return __x.__id_ < __y.__id_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
-        {return !(__y < __x);}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT
-        {return   __y < __x ;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT
-        {return !(__x < __y);}
-
-    template<class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
-        {return __os << __id.__id_;}
-
-private:
-    _LIBCPP_INLINE_VISIBILITY
-    __thread_id(pthread_t __id) : __id_(__id) {}
-
-    friend __thread_id this_thread::get_id() _NOEXCEPT;
-    friend class _LIBCPP_TYPE_VIS thread;
-    friend struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>;
-};
-
-template<>
-struct _LIBCPP_TYPE_VIS_ONLY hash<__thread_id>
-    : public unary_function<__thread_id, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(__thread_id __v) const
-    {
-        return hash<pthread_t>()(__v.__id_);
-    }
-};
-
-namespace this_thread
-{
 
-inline _LIBCPP_INLINE_VISIBILITY
-__thread_id
-get_id() _NOEXCEPT
+class _LIBCPP_TYPE_VIS thread : private __libcxx_support::thread
 {
-    return pthread_self();
-}
-
-}  // this_thread
-
-class _LIBCPP_TYPE_VIS thread
-{
-    pthread_t __t_;
+    typedef __libcxx_support::thread base;
     
     thread(const thread&);
     thread& operator=(const thread&);
 public:
     typedef __thread_id id;
-    typedef pthread_t native_handle_type;
+    typedef __libcxx_support::thread::native_handle_type native_handle_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    thread() _NOEXCEPT : __t_(0) {}
+    thread() _NOEXCEPT {}
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _Fp, class ..._Args,
               class = typename enable_if
               <
                    !is_same<typename decay<_Fp>::type, thread>::value
               >::type
              >
         explicit thread(_Fp&& __f, _Args&&... __args);
 #else  // _LIBCPP_HAS_NO_VARIADICS
     template <class _Fp> explicit thread(_Fp __f);
 #endif
     ~thread();
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;}
+    thread(thread&& __t) _NOEXCEPT = default;
     thread& operator=(thread&& __t) _NOEXCEPT;
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
+    using base::joinable;
+    using base::join;
+    using base::detach;
+    using base::get_id;
+    using base::native_handle;
 
     _LIBCPP_INLINE_VISIBILITY
-    bool joinable() const _NOEXCEPT {return __t_ != 0;}
-    void join();
-    void detach();
-    _LIBCPP_INLINE_VISIBILITY
-    id get_id() const _NOEXCEPT {return __t_;}
-    _LIBCPP_INLINE_VISIBILITY
-    native_handle_type native_handle() _NOEXCEPT {return __t_;}
+    void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
     
     static unsigned hardware_concurrency() _NOEXCEPT;
 };
 
 class __assoc_sub_state;
 
 class _LIBCPP_HIDDEN __thread_struct_imp;
 
 class _LIBCPP_TYPE_VIS __thread_struct
 {
     __thread_struct_imp* __p_;
 
     __thread_struct(const __thread_struct&);
     __thread_struct& operator=(const __thread_struct&);
 public:
     __thread_struct();
     ~__thread_struct();
 
     void notify_all_at_thread_exit(condition_variable*, mutex*);
     void __make_ready_at_thread_exit(__assoc_sub_state*);
 };
 
-_LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
+_LIBCPP_FUNC_VIS __libcxx_support::__thread_specific_ptr<__thread_struct>& __thread_local_data();
+
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+inline _LIBCPP_INLINE_VISIBILITY
+thread&
+thread::operator=(thread&& __t) _NOEXCEPT
+{
+    if (__t_ != 0)
+        terminate();
+    __t_ = __t.__t_;
+    __t.__t_ = 0;
+    return *this;
+}
+
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Fp, class ..._Args, size_t ..._Indices>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 __thread_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>)
 {

 template <class _Fp, class ..._Args,
           class
          >
 thread::thread(_Fp&& __f, _Args&&... __args)
 {
     typedef tuple<typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
     _VSTD::unique_ptr<_Gp> __p(new _Gp(__decay_copy(_VSTD::forward<_Fp>(__f)),
                                 __decay_copy(_VSTD::forward<_Args>(__args))...));
-    int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Gp>, __p.get());
-    if (__ec == 0)
-        __p.release();
-    else
-        __throw_system_error(__ec, "thread constructor failed");
+    this->start_thread(&__thread_proxy<_Gp>, _VSTD::move(__p));
 }
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Fp>
 void*
 __thread_proxy(void* __vp)
 {
     __thread_local_data().reset(new __thread_struct);
     std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
     (*__p)();
     return nullptr;
 }
 
 template <class _Fp>
 thread::thread(_Fp __f)
 {
     std::unique_ptr<_Fp> __p(new _Fp(__f));
-    int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Fp>, __p.get());
-    if (__ec == 0)
-        __p.release();
-    else
-        __throw_system_error(__ec, "thread constructor failed");
+    this->start_thread(&__thread_proxy<_Gp>, _VSTD::move(__p));
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-inline _LIBCPP_INLINE_VISIBILITY
-thread&
-thread::operator=(thread&& __t) _NOEXCEPT
-{
-    if (__t_ != 0)
-        terminate();
-    __t_ = __t.__t_;
-    __t.__t_ = 0;
-    return *this;
-}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 inline _LIBCPP_INLINE_VISIBILITY
 void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
 
 namespace this_thread
 {
 
 _LIBCPP_FUNC_VIS void sleep_for(const chrono::nanoseconds& ns);
 
 template <class _Rep, class _Period>
 void
 sleep_for(const chrono::duration<_Rep, _Period>& __d)
 {
     using namespace chrono;
     if (__d > duration<_Rep, _Period>::zero())
     {

 inline _LIBCPP_INLINE_VISIBILITY
 void
 sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
 {
     using namespace chrono;
     sleep_for(__t - steady_clock::now());
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-void yield() _NOEXCEPT {sched_yield();}
+using __libcxx_support::yield;
     
 }  // this_thread
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 #endif  // _LIBCPP_THREAD

lib/CMakeLists.txt

 set(LIBCXX_LIB_CMAKEFILES_DIR "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}"  PARENT_SCOPE)
 
 # Get sources
 file(GLOB LIBCXX_SOURCES ../src/*.cpp)
 if(WIN32)
   file(GLOB LIBCXX_WIN32_SOURCES ../src/support/win32/*.cpp)
   list(APPEND LIBCXX_SOURCES ${LIBCXX_WIN32_SOURCES})
 elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
   file(GLOB LIBCXX_SOLARIS_SOURCES ../src/support/solaris/*.c)
   list(APPEND LIBCXX_SOURCES ${LIBCXX_SOLARIS_SOURCES})
+elseif(UNIX)
+  file(GLOB LIBCXX_PTHREAD_SOURCES ../src/support/pthread/*.cpp)
+  list(APPEND LIBCXX_SOURCES ${LIBCXX_PTHREAD_SOURCES})
 endif()
 
 # Add all the headers to the project for IDEs.
 if (MSVC_IDE OR XCODE)
   file(GLOB_RECURSE LIBCXX_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/*)
   if(WIN32)
     file( GLOB LIBCXX_WIN32_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/support/win32/*.h)
     list(APPEND LIBCXX_HEADERS ${LIBCXX_WIN32_HEADERS})
   endif()
+  if(XCODE)
+    file(GLOB_RECURSE LIBCXX_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/support/pthread/*)
+  endif()
   # Force them all into the headers dir on MSVC, otherwise they end up at
   # project scope because they don't have extensions.
   if (MSVC_IDE)
     source_group("Header Files" FILES ${LIBCXX_HEADERS})
   endif()
 endif()
 
 if (LIBCXX_ENABLE_SHARED)

src/algorithm.cpp

 template bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&);
 template bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&);
 template bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&);
 template bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&);
 
 template unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&);
 
 #ifndef _LIBCPP_HAS_NO_THREADS
-static pthread_mutex_t __rs_mut = PTHREAD_MUTEX_INITIALIZER;
+static mutex __rs_mut;
 #endif
 unsigned __rs_default::__c_ = 0;
 
 __rs_default::__rs_default()
 {
 #ifndef _LIBCPP_HAS_NO_THREADS
-    pthread_mutex_lock(&__rs_mut);
+    __rs_mut.lock();
 #endif
     __c_ = 1;
 }
 
 __rs_default::__rs_default(const __rs_default&)
 {
     ++__c_;
 }
 
 __rs_default::~__rs_default()
 {
 #ifndef _LIBCPP_HAS_NO_THREADS
     if (--__c_ == 0)
-        pthread_mutex_unlock(&__rs_mut);
+        __rs_mut.unlock();
 #else
     --__c_;
 #endif
 }
 
 __rs_default::result_type
 __rs_default::operator()()
 {

src/condition_variable.cpp

 
 #include "condition_variable"
 #include "thread"
 #include "system_error"
 #include "cassert"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-condition_variable::~condition_variable()
-{
-    pthread_cond_destroy(&__cv_);
-}
-
-void
-condition_variable::notify_one() _NOEXCEPT
-{
-    pthread_cond_signal(&__cv_);
-}
-
-void
-condition_variable::notify_all() _NOEXCEPT
-{
-    pthread_cond_broadcast(&__cv_);
-}
-
 void
 condition_variable::wait(unique_lock<mutex>& lk) _NOEXCEPT
 {
     if (!lk.owns_lock())
         __throw_system_error(EPERM,
                                   "condition_variable::wait: mutex not locked");
-    int ec = pthread_cond_wait(&__cv_, lk.mutex()->native_handle());
-    if (ec)
-        __throw_system_error(ec, "condition_variable wait failed");
+    base::__wait(lk.mutex()->native_handle());
 }
 
 void
 condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
      chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp) _NOEXCEPT
 {
-    using namespace chrono;
     if (!lk.owns_lock())
         __throw_system_error(EPERM,
                             "condition_variable::timed wait: mutex not locked");
-    nanoseconds d = tp.time_since_epoch();
-    if (d > nanoseconds(0x59682F000000E941))
-        d = nanoseconds(0x59682F000000E941);
-    timespec ts;
-    seconds s = duration_cast<seconds>(d);
-    typedef decltype(ts.tv_sec) ts_sec;
-    _LIBCPP_CONSTEXPR ts_sec ts_sec_max = numeric_limits<ts_sec>::max();
-    if (s.count() < ts_sec_max)
-    {
-        ts.tv_sec = static_cast<ts_sec>(s.count());
-        ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((d - s).count());
-    }
-    else
-    {
-        ts.tv_sec = ts_sec_max;
-        ts.tv_nsec = giga::num - 1;
-    }
-    int ec = pthread_cond_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
-    if (ec != 0 && ec != ETIMEDOUT)
-        __throw_system_error(ec, "condition_variable timed_wait failed");
+    base::__do_timed_wait(lk.mutex()->native_handle(), tp);
 }
 
 void
 notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
 {
     __thread_local_data()->notify_all_at_thread_exit(&cond, lk.release());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS

src/memory.cpp

__shared_weak_count::__get_deleter(const type_info&) const _NOEXCEPT
     return 0;
 }
 
 #endif  // _LIBCPP_NO_RTTI
 
 #if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
 
 static const std::size_t __sp_mut_count = 16;
-static pthread_mutex_t mut_back_imp[__sp_mut_count] =
-{
-    PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
-    PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
-    PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
-    PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER
-};
+static mutex mut_back_imp[__sp_mut_count];
 
-static mutex* mut_back = reinterpret_cast<std::mutex*>(mut_back_imp);
+static mutex* mut_back = mut_back_imp;
 
 _LIBCPP_CONSTEXPR __sp_mut::__sp_mut(void* p) _NOEXCEPT
    : __lx(p)
 {
 }
 
 void
 __sp_mut::lock() _NOEXCEPT

src/mutex.cpp

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 const defer_lock_t  defer_lock = {};
 const try_to_lock_t try_to_lock = {};
 const adopt_lock_t  adopt_lock = {};
 
-mutex::~mutex()
-{
-    pthread_mutex_destroy(&__m_);
-}
 
-void
-mutex::lock()
-{
-    int ec = pthread_mutex_lock(&__m_);
-    if (ec)
-        __throw_system_error(ec, "mutex lock failed");
-}
-
-bool
-mutex::try_lock() _NOEXCEPT
-{
-    return pthread_mutex_trylock(&__m_) == 0;
-}
-
-void
-mutex::unlock() _NOEXCEPT
-{
-    int ec = pthread_mutex_unlock(&__m_);
-    (void)ec;
-    assert(ec == 0);
-}
-
-// recursive_mutex
-
-recursive_mutex::recursive_mutex()
-{
-    pthread_mutexattr_t attr;
-    int ec = pthread_mutexattr_init(&attr);
-    if (ec)
-        goto fail;
-    ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-    if (ec)
-    {
-        pthread_mutexattr_destroy(&attr);
-        goto fail;
-    }
-    ec = pthread_mutex_init(&__m_, &attr);
-    if (ec)
-    {
-        pthread_mutexattr_destroy(&attr);
-        goto fail;
-    }
-    ec = pthread_mutexattr_destroy(&attr);
-    if (ec)
-    {
-        pthread_mutex_destroy(&__m_);
-        goto fail;
-    }
-    return;
-fail:
-    __throw_system_error(ec, "recursive_mutex constructor failed");
-}
-
-recursive_mutex::~recursive_mutex()
-{
-    int e = pthread_mutex_destroy(&__m_);
-    (void)e;
-    assert(e == 0);
-}
-
-void
-recursive_mutex::lock()
-{
-    int ec = pthread_mutex_lock(&__m_);
-    if (ec)
-        __throw_system_error(ec, "recursive_mutex lock failed");
-}
-
-void
-recursive_mutex::unlock() _NOEXCEPT
-{
-    int e = pthread_mutex_unlock(&__m_);
-    (void)e;
-    assert(e == 0);
-}
-
-bool
-recursive_mutex::try_lock() _NOEXCEPT
-{
-    return pthread_mutex_trylock(&__m_) == 0;
-}
 
 // timed_mutex
 
 timed_mutex::timed_mutex()
     : __locked_(false)
 {
 }
 
timed_mutex::unlock() _NOEXCEPT
     __locked_ = false;
     __cv_.notify_one();
 }
 
 // recursive_timed_mutex
 
 recursive_timed_mutex::recursive_timed_mutex()
     : __count_(0),
-      __id_(0)
+      __id_()
 {
 }
 
 recursive_timed_mutex::~recursive_timed_mutex()
 {
     lock_guard<mutex> _(__m_);
 }
 
 void
 recursive_timed_mutex::lock()
 {
-    pthread_t id = pthread_self();
+    __libcxx_support::__thread_id id = __libcxx_support::get_id();
     unique_lock<mutex> lk(__m_);
-    if (pthread_equal(id, __id_))
+    if (id == __id_)
     {
         if (__count_ == numeric_limits<size_t>::max())
             __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
         ++__count_;
         return;
     }
     while (__count_ != 0)
         __cv_.wait(lk);
     __count_ = 1;
     __id_ = id;
 }
 
 bool
 recursive_timed_mutex::try_lock() _NOEXCEPT
 {
-    pthread_t id = pthread_self();
+    __libcxx_support::__thread_id id = __libcxx_support::get_id();
     unique_lock<mutex> lk(__m_, try_to_lock);
-    if (lk.owns_lock() && (__count_ == 0 || pthread_equal(id, __id_)))
+    if (lk.owns_lock() && (__count_ == 0 || (id == __id_)))
     {
         if (__count_ == numeric_limits<size_t>::max())
             return false;
         ++__count_;
         __id_ = id;
         return true;
     }
     return false;
 }
 
 void
 recursive_timed_mutex::unlock() _NOEXCEPT
 {
     unique_lock<mutex> lk(__m_);
     if (--__count_ == 0)
     {
-        __id_ = 0;
+        __id_.reset();
         lk.unlock();
         __cv_.notify_one();
     }
 }
 
-#endif // !_LIBCPP_HAS_NO_THREADS
-
-// If dispatch_once_f ever handles C++ exceptions, and if one can get to it
-// without illegal macros (unexpected macros not beginning with _UpperCase or
-// __lowercase), and if it stops spinning waiting threads, then call_once should
-// call into dispatch_once_f instead of here. Relevant radar this code needs to
-// keep in sync with:  7741191.
 
-#ifndef _LIBCPP_HAS_NO_THREADS
-static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t  cv  = PTHREAD_COND_INITIALIZER;
-#endif
-
-/// NOTE: Changes to flag are done via relaxed atomic stores
-///       even though the accesses are protected by a mutex because threads
-///       just entering 'call_once` concurrently read from flag.
-void
-__call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
-{
-#if defined(_LIBCPP_HAS_NO_THREADS)
-    if (flag == 0)
-    {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        try
-        {
-#endif  // _LIBCPP_NO_EXCEPTIONS
-            flag = 1;
-            func(arg);
-            flag = ~0ul;
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            flag = 0ul;
-            throw;
-        }
-#endif  // _LIBCPP_NO_EXCEPTIONS
-    }
-#else // !_LIBCPP_HAS_NO_THREADS
-    pthread_mutex_lock(&mut);
-    while (flag == 1)
-        pthread_cond_wait(&cv, &mut);
-    if (flag == 0)
-    {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        try
-        {
-#endif  // _LIBCPP_NO_EXCEPTIONS
-            __libcpp_relaxed_store(&flag, 1ul);
-            pthread_mutex_unlock(&mut);
-            func(arg);
-            pthread_mutex_lock(&mut);
-            __libcpp_relaxed_store(&flag, ~0ul);
-            pthread_mutex_unlock(&mut);
-            pthread_cond_broadcast(&cv);
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            pthread_mutex_lock(&mut);
-            __libcpp_relaxed_store(&flag, 0ul);
-            pthread_mutex_unlock(&mut);
-            pthread_cond_broadcast(&cv);
-            throw;
-        }
-#endif  // _LIBCPP_NO_EXCEPTIONS
-    }
-    else
-        pthread_mutex_unlock(&mut);
 #endif // !_LIBCPP_HAS_NO_THREADS
 
-}
 
 _LIBCPP_END_NAMESPACE_STD

src/support/pthread/condition_variable.cpp

+// -*- C++ -*-
+//===--------------- support/pthread/condition_variable.cpp --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "__config"
+#ifndef _LIBCPP_HAS_NO_THREADS
+#include <chrono>
+#include <system_error>
+#include <support/pthread/mutex.hpp>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __libcxx_support
+{
+
+condition_variable::~condition_variable()
+{
+    pthread_cond_destroy(&__cv_);
+}
+
+void
+condition_variable::notify_one() _NOEXCEPT
+{
+    pthread_cond_signal(&__cv_);
+}
+
+void
+condition_variable::notify_all() _NOEXCEPT
+{
+    pthread_cond_broadcast(&__cv_);
+}
+
+void
+condition_variable::__wait(pthread_mutex_t* lk) _NOEXCEPT
+{
+    int ec = pthread_cond_wait(&__cv_, lk);
+    if (ec)
+        __throw_system_error(ec, "condition_variable wait failed");
+}
+
+void
+condition_variable::__do_timed_wait(pthread_mutex_t* lk,
+    _VSTD::chrono::time_point<_VSTD::chrono::system_clock, _VSTD::chrono::nanoseconds> tp) _NOEXCEPT
+{
+    using namespace _VSTD::chrono;
+    nanoseconds d = tp.time_since_epoch();
+    if (d > nanoseconds(0x59682F000000E941))
+        d = nanoseconds(0x59682F000000E941);
+    timespec ts;
+    seconds s = duration_cast<seconds>(d);
+    typedef decltype(ts.tv_sec) ts_sec;
+    _LIBCPP_CONSTEXPR ts_sec ts_sec_max = numeric_limits<ts_sec>::max();
+    if (s.count() < ts_sec_max)
+    {
+        ts.tv_sec = static_cast<ts_sec>(s.count());
+        ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((d - s).count());
+    }
+    else
+    {
+        ts.tv_sec = ts_sec_max;
+        ts.tv_nsec = giga::num - 1;
+    }
+    int ec = pthread_cond_timedwait(&__cv_, lk, &ts);
+    if (ec != 0 && ec != ETIMEDOUT)
+        __throw_system_error(ec, "condition_variable timed_wait failed");
+}
+
+} // namespace __libcxx_support
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS

src/support/pthread/mutex.cpp

+// -*- C++ -*-
+//===---------------------- support/pthread/mutex.cpp ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "__config"
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+#include <system_error>
+#include <support/pthread/mutex.hpp>
+#include <cassert>
+#include "../atomic_support.h"
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __libcxx_support
+{
+
+mutex::~mutex()
+{
+    pthread_mutex_destroy(&__m_);
+}
+
+void
+mutex::lock()
+{
+    int ec = pthread_mutex_lock(&__m_);
+    if (ec)
+        __throw_system_error(ec, "mutex lock failed");
+}
+
+bool
+mutex::try_lock() _NOEXCEPT
+{
+    return pthread_mutex_trylock(&__m_) == 0;
+}
+
+void
+mutex::unlock() _NOEXCEPT
+{
+    int ec = pthread_mutex_unlock(&__m_);
+    (void)ec;
+    assert(ec == 0);
+}
+
+// recursive_mutex
+
+recursive_mutex::recursive_mutex()
+{
+    pthread_mutexattr_t attr;
+    int ec = pthread_mutexattr_init(&attr);
+    if (ec)
+        goto fail;
+    ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    if (ec)
+    {
+        pthread_mutexattr_destroy(&attr);
+        goto fail;
+    }
+    ec = pthread_mutex_init(&__m_, &attr);
+    if (ec)
+    {
+        pthread_mutexattr_destroy(&attr);
+        goto fail;
+    }
+    ec = pthread_mutexattr_destroy(&attr);
+    if (ec)
+    {
+        pthread_mutex_destroy(&__m_);
+        goto fail;
+    }
+    return;
+fail:
+    __throw_system_error(ec, "recursive_mutex constructor failed");
+}
+
+recursive_mutex::~recursive_mutex()
+{
+    int e = pthread_mutex_destroy(&__m_);
+    (void)e;
+    assert(e == 0);
+}
+
+void
+recursive_mutex::lock()
+{
+    int ec = pthread_mutex_lock(&__m_);
+    if (ec)
+        __throw_system_error(ec, "recursive_mutex lock failed");
+}
+
+void
+recursive_mutex::unlock() _NOEXCEPT
+{
+    int e = pthread_mutex_unlock(&__m_);
+    (void)e;
+    assert(e == 0);
+}
+
+bool
+recursive_mutex::try_lock() _NOEXCEPT
+{
+    return pthread_mutex_trylock(&__m_) == 0;
+}
+
+// If dispatch_once_f ever handles C++ exceptions, and if one can get to it
+// without illegal macros (unexpected macros not beginning with _UpperCase or
+// __lowercase), and if it stops spinning waiting threads, then call_once should
+// call into dispatch_once_f instead of here. Relevant radar this code needs to
+// keep in sync with:  7741191.
+
+static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t  cv  = PTHREAD_COND_INITIALIZER;
+#endif // _LIBCPP_HAS_NO_THREADS
+
+
+/// NOTE: Changes to flag are done via relaxed atomic stores
+///       even though the accesses are protected by a mutex because threads
+///       just entering 'call_once` concurrently read from flag.
+void
+__call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
+{
+#if defined(_LIBCPP_HAS_NO_THREADS)
+    if (flag == 0)
+    {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        try
+        {
+#endif  // _LIBCPP_NO_EXCEPTIONS
+            flag = 1;
+            func(arg);
+            flag = ~0ul;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        }
+        catch (...)
+        {
+            flag = 0ul;
+            throw;
+        }
+#endif  // _LIBCPP_NO_EXCEPTIONS
+    }
+#else // !_LIBCPP_HAS_NO_THREADS
+    pthread_mutex_lock(&mut);
+    while (flag == 1)
+        pthread_cond_wait(&cv, &mut);
+    if (flag == 0)
+    {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        try
+        {
+#endif  // _LIBCPP_NO_EXCEPTIONS
+            __libcpp_relaxed_store(&flag, 1ul);
+            pthread_mutex_unlock(&mut);
+            func(arg);
+            pthread_mutex_lock(&mut);
+            __libcpp_relaxed_store(&flag, ~0ul);
+            pthread_mutex_unlock(&mut);
+            pthread_cond_broadcast(&cv);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        }
+        catch (...)
+        {
+            pthread_mutex_lock(&mut);
+            __libcpp_relaxed_store(&flag, 0ul);
+            pthread_mutex_unlock(&mut);
+            pthread_cond_broadcast(&cv);
+            throw;
+        }
+#endif  // _LIBCPP_NO_EXCEPTIONS
+    }
+    else
+        pthread_mutex_unlock(&mut);
+#endif // !_LIBCPP_HAS_NO_THREADS
+
+}
+
+} // namespace __libcxx_support
+
+_LIBCPP_END_NAMESPACE_STD

src/support/pthread/thread.cpp

+// -*- C++ -*-
+//===---------------------- support/pthread/thread.cpp --------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "__config"
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+#include <support/pthread/thread.hpp>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __libcxx_support
+{
+    
+void
+thread::join()
+{
+    int ec = pthread_join(__t_, 0);
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    if (ec)
+        throw system_error(error_code(ec, system_category()), "thread::join failed");
+#else
+    (void)ec;
+#endif  // _LIBCPP_NO_EXCEPTIONS
+    __t_ = 0;
+}
+
+void
+thread::detach()
+{
+    int ec = EINVAL;
+    if (__t_ != 0)
+    {
+        ec = pthread_detach(__t_);
+        if (ec == 0)
+            __t_ = 0;
+    }
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    if (ec)
+        throw system_error(error_code(ec, system_category()), "thread::detach failed");
+#endif  // _LIBCPP_NO_EXCEPTIONS
+}
+
+} // namespace __libcxx_support
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_THREADS

src/thread.cpp

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 thread::~thread()
 {
     if (__t_ != 0)
         terminate();
 }
 
-void
-thread::join()
-{
-    int ec = pthread_join(__t_, 0);
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    if (ec)
-        throw system_error(error_code(ec, system_category()), "thread::join failed");
-#else
-    (void)ec;
-#endif  // _LIBCPP_NO_EXCEPTIONS
-    __t_ = 0;
-}
-
-void
-thread::detach()
-{
-    int ec = EINVAL;
-    if (__t_ != 0)
-    {
-        ec = pthread_detach(__t_);
-        if (ec == 0)
-            __t_ = 0;
-    }
-#ifndef _LIBCPP_NO_EXCEPTIONS
-    if (ec)
-        throw system_error(error_code(ec, system_category()), "thread::detach failed");
-#endif  // _LIBCPP_NO_EXCEPTIONS
-}
 
 unsigned
 thread::hardware_concurrency() _NOEXCEPT
 {
 #if defined(CTL_HW) && defined(HW_NCPU)
     unsigned n;
     int mib[2] = {CTL_HW, HW_NCPU};
     std::size_t s = sizeof(n);
if (ns > nanoseconds::zero())
 
         while (nanosleep(&ts, &ts) == -1 && errno == EINTR)
             ;
     }
 }
 
 }  // this_thread
 
-__thread_specific_ptr<__thread_struct>&
+__libcxx_support::__thread_specific_ptr<__thread_struct>&
 __thread_local_data()
 {
-    static __thread_specific_ptr<__thread_struct> __p;
+    static __libcxx_support::__thread_specific_ptr<__thread_struct> __p;
     return __p;
 }
 
 // __thread_struct_imp
 
 template <class T>
 class _LIBCPP_HIDDEN __hidden_allocator
 {