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

18

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

269

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

181–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).

287

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

18

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

269

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

181–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

269

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

181–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

269

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

269

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

[espositofulvio]

include/__mutex_base

269

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

751

#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

751

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

751

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

751

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.

751

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

751

@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

751

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

751

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

751

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

751

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

751

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

751

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

751

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

751

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

751

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

751

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

751

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

536

This looks like an ABI break to me.

[EricWF]

Added more inline comments.

include/__mutex_base

38

Why was the cast insignificant?

277

Why was the cast insignificant?

include/thread

421

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

52

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

52

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

38

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

52

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

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

include/support/pthread/mutex.h

27

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

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

62

Shouldn't these functions take __os_recursive_mutex* types?

85

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

include/support/pthread/thread.h

60

res needs to be an int, not a bool.

67

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

114

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

include/thread

238

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

244

Same as above.

260

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

393

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.

.gitignore

 # Django stuff:
 *.log
 
 # Sphinx documentation
 docs/_build/
 
 # PyBuilder
 target/
+

CMakeLists.txt

 endif()
 
 string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 
 #===============================================================================
 # Setup Compiler Flags
 #===============================================================================
 
-include(HandleLibCXXABI) # Steup the ABI library flags
+include(HandleLibCXXABI) # Setup the ABI library flags
 
 # Include macros for adding and removing libc++ flags.
 include(HandleLibcxxFlags)
 
 # Remove flags that may have snuck in.
 remove_flags(-DNDEBUG -UNDEBUG -D_DEBUG
              -stdlib=libc++ -stdlib=libstdc++ -lc++abi -m32)
 

include/__config

 #    define _LIBCPP_NO_RTTI
 #  endif
 #endif
 
 #ifndef _LIBCPP_WEAK
 #  define _LIBCPP_WEAK __attribute__((__weak__))
 #endif
 
+// Thread API
+#ifndef _LIBCPP_HAS_NO_THREADS
+# if defined(__FreeBSD__) || \
+    defined(__NetBSD__) || \
+    defined(__linux__) || \
+    defined(__APPLE__) || \
+    defined(__CloudABI__)
+#  define _LIBCPP_THREAD_API _LIBCPP_PTHREAD
+# else
+#  error "No thread API"
+# endif // _LIBCPP_THREAD_API
+#endif // _LIBCPP_HAS_NO_THREADS
+
+    
 #if defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK) && !defined(_LIBCPP_HAS_NO_THREADS)
 #  error _LIBCPP_HAS_NO_MONOTONIC_CLOCK may only be defined when \
          _LIBCPP_HAS_NO_THREADS is defined.
 #endif
 
 // Systems that use capability-based security (FreeBSD with Capsicum,
 // Nuxi CloudABI) may only provide local filesystem access (using *at()).
 // Functions like open(), rename(), unlink() and stat() should not be

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>
-#ifndef _LIBCPP_HAS_NO_THREADS
-#include <pthread.h>
-#endif
+#include <support/mutex.h>
+#include <support/condition_variable.h>
 
 #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_;
+    typedef __libcpp_support::__os_mutex __mutex_type;
+    __mutex_type __m_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_HAS_NO_CONSTEXPR
-     constexpr mutex() _NOEXCEPT : __m_(PTHREAD_MUTEX_INITIALIZER) {}
+    constexpr mutex() _NOEXCEPT : __m_(__libcpp_support::__os_mutex_init) {}
 #else
-     mutex() _NOEXCEPT {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
+     mutex() _NOEXCEPT {__m_ = __libcpp_support::__os_mutex_init;}
 #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;
+    typedef __mutex_type* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
 };
 
 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)

 //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
 {
-    pthread_cond_t __cv_;
+    typedef __libcpp_support::__os_cond_var __cond_var_type;
+    __cond_var_type  __cv_;
 public:
     _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_HAS_NO_CONSTEXPR
-    constexpr condition_variable() : __cv_(PTHREAD_COND_INITIALIZER) {}
+    constexpr condition_variable() : __cv_(__libcpp_support::__os_cond_var_init) {}
 #else
-    condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
+    condition_variable() {__cv_ = __libcpp_support::__os_cond_var_init;}
 #endif
     ~condition_variable();
 
 private:
     condition_variable(const condition_variable&); // = delete;
     condition_variable& operator=(const condition_variable&); // = delete;
 
 public:
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;
+    typedef __cond_var_type* 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
 

include/mutex

 */
 
 #include <__config>
 #include <__mutex_base>
 #include <functional>
 #include <memory>
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 #include <tuple>
 #endif
-#ifndef _LIBCPP_HAS_NO_THREADS
-#include <sched.h>
-#endif
+#include <support/thread.h>
 
 #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_;
+    typedef __libcpp_support::__os_mutex __mutex_type;
+    __mutex_type __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;
+    void unlock() _NOEXCEPT;
 
-    typedef pthread_mutex_t* native_handle_type;
+    typedef __mutex_type* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY
     native_handle_type native_handle() {return &__m_;}
 };
 
 class _LIBCPP_TYPE_VIS timed_mutex
 {
     mutex              __m_;
     condition_variable __cv_;
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_;
+    __libcpp_support::__os_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();
+    using namespace __libcpp_support;
+    __os_thread_id __id = __os_get_current_thread_id();
     unique_lock<mutex> lk(__m_);
-    if (pthread_equal(__id, __id_))
+    if (__os_thread_id_compare(__id, __id_) == 0)
     {
         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();
+        __libcpp_support::__os_yield();
         {
             unique_lock<_L1> __u1(__l1);
             if (__l0.try_lock())
             {
                 __u1.release();
                 break;
             }
         }
-        sched_yield();
+        __libcpp_support::__os_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();
+            __libcpp_support::__os_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();
+            __libcpp_support::__os_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*));
 
 #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/condition_variable.h

+// -*- 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_SUPPORT_CONDITION_VARIABLE_H
+#define _LIBCPP_SUPPORT_CONDITION_VARIABLE_H
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+#define _LIBCPP_INCLUDE_THREAD_API
+
+#if _LIBCPP_THREAD_API == _LIBCPP_PTHREAD
+# include <support/pthread/condition_variable.h>
+#else
+# error "No thread API found"
+#endif // _LIBCPP_THREAD_API == _LIBCPP_PTHREAD
+
+#undef _LIBCPP_INCLUDE_THREAD_API
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP_SUPPORT_CONDITION_VARIABLE_H

include/support/mutex.h

+// -*- 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_SUPPORT_MUTEX_H
+#define _LIBCPP_SUPPORT_MUTEX_H
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+#define _LIBCPP_INCLUDE_THREAD_API
+
+#if _LIBCPP_THREAD_API == _LIBCPP_PTHREAD
+# include <support/pthread/mutex.h>
+#else
+# error "No thread API found"
+#endif // _LIBCPP_THREAD_API == _LIBCPP_PTHREAD
+
+#undef _LIBCPP_INCLUDE_THREAD_API
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP_SUPPORT_MUTEX_H

include/support/pthread/condition_variable.h

+// -*- 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_SUPPORT_PTHREAD_CONDITION_VARIABLE_H
+#define _LIBCPP_SUPPORT_PTHREAD_CONDITION_VARIABLE_H
+
+#ifndef _LIBCPP_INCLUDE_THREAD_API
+# error "This header can't be included directly"
+#endif // _LIBCPP_INCLUDE_THREAD_API
+
+#include <pthread.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __libcpp_support
+{
+
+typedef pthread_cond_t __os_cond_var;
+typedef pthread_mutex_t __os_mutex;
+_LIBCPP_CONSTEXPR pthread_cond_t __os_cond_var_init = PTHREAD_COND_INITIALIZER;
+
+inline _LIBCPP_INLINE_VISIBILITY
+void __os_cond_var_destroy(__os_cond_var* __cv)
+{
+    pthread_cond_destroy(__cv);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void __os_cond_var_notify_one(__os_cond_var* __cv)
+{
+    pthread_cond_signal(__cv);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void __os_cond_var_notify_all(__os_cond_var* __cv)
+{
+    pthread_cond_broadcast(__cv);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_cond_var_wait(__os_cond_var* __cv, __os_mutex* __m)
+{
+    return pthread_cond_wait(__cv, __m);
+}
+
+_LIBCPP_FUNC_VIS
+void __os_cond_var_timed_wait(__os_cond_var* __cv,
+     __os_mutex* __m,
+     chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp);
+
+} // namespace __libcpp_support
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SUPPORT_PTHREAD_CONDITION_VARIABLE_H

include/support/pthread/mutex.h

+// -*- 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_SUPPORT_PTHREAD_MUTEX_H
+#define _LIBCPP_SUPPORT_PTHREAD_MUTEX_H
+
+#ifndef _LIBCPP_INCLUDE_THREAD_API
+# error "This header can't be included directly"
+#endif // _LIBCPP_INCLUDE_THREAD_API
+
+#include <pthread.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __libcpp_support
+{
+
+// mutex
+typedef pthread_mutex_t __os_mutex;
+_LIBCPP_CONSTEXPR pthread_mutex_t __os_mutex_init = PTHREAD_MUTEX_INITIALIZER;
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_mutex_lock(__os_mutex* __m)
+{
+    return pthread_mutex_lock(__m);
+}
+    
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_mutex_trylock(__os_mutex* __m)
+{
+    return pthread_mutex_trylock(__m);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_mutex_unlock(__os_mutex* __m)
+{
+    return pthread_mutex_unlock(__m);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_mutex_destroy(__os_mutex* __m)
+{
+    return pthread_mutex_destroy(__m);
+}
+
+// pthread hides differences between recursive and non-recursive mutexes
+// internally, other platform (e.g. Windows) might not, thus the following
+// is like the above except for init
+typedef pthread_mutex_t __os_recursive_mutex;
+
+_LIBCPP_FUNC_VIS
+void __os_recursive_mutex_init(__os_mutex* __m);
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_recursive_mutex_lock(__os_mutex* __m)
+{
+    return pthread_mutex_lock(__m);
+}
+    
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_recursive_mutex_trylock(__os_mutex* __m)
+{
+    return pthread_mutex_trylock(__m);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_recursive_mutex_unlock(__os_mutex* __m)
+{
+    return pthread_mutex_unlock(__m);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_recursive_mutex_destroy(__os_mutex* __m)
+{
+    return pthread_mutex_destroy(__m);
+}
+
+_LIBCPP_FUNC_VIS void __os_call_once(volatile unsigned long&, void*, void(*)(void*));
+
+
+} // namespace __libcpp_support
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SUPPORT_PTHREAD_MUTEX_H
+

include/support/pthread/thread.h

+// -*- 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_SUPPORT_PTHREAD_THREAD_H
+#define _LIBCPP_SUPPORT_PTHREAD_THREAD_H
+
+#ifndef _LIBCPP_INCLUDE_THREAD_API
+# error "This header can't be included directly"
+#endif // _LIBCPP_INCLUDE_THREAD_API
+
+#include <pthread.h>
+#include <sched.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __libcpp_support
+{
+
+// thread local
+typedef pthread_key_t __os_tl_key;
+
+template<class _Func>
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_tl_create(__os_tl_key* __key, _Func&& __at_exit)
+{
+    return pthread_key_create(__key, __at_exit);
+}
+    
+inline _LIBCPP_INLINE_VISIBILITY
+void __os_tl_destroy(__os_tl_key __key)
+{
+    pthread_key_delete(__key);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void* __os_tl_get(__os_tl_key __key)
+{
+    return pthread_getspecific(__key);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void __os_tl_set(__os_tl_key __key, void* __p)
+{
+    pthread_setspecific(__key, __p);
+}
+
+// thread id
+typedef pthread_t __os_thread_id;
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_thread_id_compare( __os_thread_id t1, __os_thread_id t2)
+{
+    bool res = pthread_equal(t1, t2);
+    return res != 0 ? 0 : (t1 < t2 ? -1 : 1);
+}
+
+template<class _CharT, class _Traits>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_ostream<_CharT, _Traits>&
+__os_write_to_ostream(basic_ostream<_CharT, _Traits>& __os, __os_thread_id __id)
+{
+    return __os << __id;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+__os_thread_id __os_get_current_thread_id()
+{
+    return pthread_self();
+}
+
+
+// thread
+typedef pthread_t __os_thread;
+_LIBCPP_CONSTEXPR pthread_t __os_thread_init = 0;
+
+template<class _Func, class _Arg>
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_create_thread(__os_thread* __t, _Func&& __f, _Arg&& __arg)
+{
+    return pthread_create(__t, 0, __f, __arg);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+__os_thread_id __os_get_thread_id(__os_thread __t)
+{
+    return __t;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_thread_join(__os_thread t)
+{
+    return pthread_join(t, 0);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+int __os_thread_detach(__os_thread t)
+{
+    return pthread_detach(t);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void __os_yield()
+{
+    sched_yield();
+}
+
+_LIBCPP_FUNC_VIS void __os_sleep_for(const chrono::nanoseconds& ns);
+
+} // namespace __libcpp_support
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SUPPORT_PTHREAD_THREAD_H
+

include/support/thread.h

+// -*- 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_SUPPORT_THREAD_H
+#define _LIBCPP_SUPPORT_THREAD_H
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+#define _LIBCPP_INCLUDE_THREAD_API
+
+#if _LIBCPP_THREAD_API == _LIBCPP_PTHREAD
+# include <support/pthread/thread.h>
+#else
+# error "No thread API found"
+#endif // _LIBCPP_THREAD_API == _LIBCPP_PTHREAD
+#undef _LIBCPP_INCLUDE_THREAD_API
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP_SUPPORT_THREAD_H

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>
+#include <support/thread.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #define __STDCPP_THREADS__ __cplusplus
 
 #ifdef _LIBCPP_HAS_NO_THREADS
public:
 
     void notify_all_at_thread_exit(condition_variable*, mutex*);
     void __make_ready_at_thread_exit(__assoc_sub_state*);
 };
 
 template <class _Tp>
 class __thread_specific_ptr
 {
-    pthread_key_t __key_;
+    __libcpp_support::__os_tl_key __key_;
 
      // Only __thread_local_data() may construct a __thread_specific_ptr
      // and only with _Tp == __thread_struct.
     static_assert((is_same<_Tp, __thread_struct>::value), "");
     __thread_specific_ptr();
     friend _LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
 
     __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();
 
     _LIBCPP_INLINE_VISIBILITY
-    pointer get() const {return static_cast<_Tp*>(pthread_getspecific(__key_));}
+    pointer get() const {return static_cast<_Tp*>(__libcpp_support::__os_tl_get(__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);
+    int __ec = __libcpp_support::__os_tl_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()
 {
     // __thread_specific_ptr is only created with a static storage duration
     // so this destructor is only invoked during program termination. Invoking
     // pthread_key_delete(__key_) may prevent other threads from deleting their
     // thread local data. For this reason we leak the key.
 }
 
 template <class _Tp>
 typename __thread_specific_ptr<_Tp>::pointer
 __thread_specific_ptr<_Tp>::release()
 {
     pointer __p = get();
-    pthread_setspecific(__key_, 0);
+    __libcpp_support::__os_tl_set(__key_, 0);
     return __p;
 }
 
 template <class _Tp>
 void
 __thread_specific_ptr<_Tp>::reset(pointer __p)
 {
     pointer __p_old = get();
-    pthread_setspecific(__key_, __p);
+    __libcpp_support::__os_tl_set(__key_, __p);
     delete __p_old;
 }
 
 class _LIBCPP_TYPE_VIS thread;
 class _LIBCPP_TYPE_VIS __thread_id;
 
 namespace this_thread
 {
 
 _LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
 
 }  // 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_;
+    __libcpp_support::__os_thread_id __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_;}
+        {return __libcpp_support::__os_thread_id_compare(__x.__id_, __y.__id_) == 0;}
     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_;}
+        {return  __libcpp_support::__os_thread_id_compare(__x.__id_, __y.__id_) < 0;}
     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_;}
+        {return __libcpp_support::__os_write_to_ostream(__os, __id.__id_);}
 
 private:
     _LIBCPP_INLINE_VISIBILITY
-    __thread_id(pthread_t __id) : __id_(__id) {}
+    __thread_id(__libcpp_support::__os_thread_id __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_);
+        return hash<__libcpp_support::__os_thread_id>()(__v.__id_);
     }
 };
 
 namespace this_thread
 {
 
 inline _LIBCPP_INLINE_VISIBILITY
 __thread_id
 get_id() _NOEXCEPT
 {
-    return pthread_self();
+    return __libcpp_support::__os_get_current_thread_id();
 }
 
 }  // this_thread
 
 class _LIBCPP_TYPE_VIS thread
 {
-    pthread_t __t_;
+    typedef __libcpp_support::__os_thread __thread_type;
+    __thread_type __t_;
 
     thread(const thread&);
     thread& operator=(const thread&);
 public:
     typedef __thread_id id;
-    typedef pthread_t native_handle_type;
+    typedef __thread_type native_handle_type;
 
     _LIBCPP_INLINE_VISIBILITY
-    thread() _NOEXCEPT : __t_(0) {}
+    thread() _NOEXCEPT : __t_(__libcpp_support::__os_thread_init) {}
 #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);
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
 
     _LIBCPP_INLINE_VISIBILITY
     bool joinable() const _NOEXCEPT {return __t_ != 0;}
     void join();
     void detach();
     _LIBCPP_INLINE_VISIBILITY
-    id get_id() const _NOEXCEPT {return __t_;}
+    id get_id() const _NOEXCEPT {return __libcpp_support::__os_get_thread_id(__t_);}
     _LIBCPP_INLINE_VISIBILITY
     native_handle_type native_handle() _NOEXCEPT {return __t_;}
 
     static unsigned hardware_concurrency() _NOEXCEPT;
 };
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 

 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());
+    int __ec = __libcpp_support::__os_create_thread(&__t_, &__thread_proxy<_Gp>, __p.get());
     if (__ec == 0)
         __p.release();
     else
         __throw_system_error(__ec, "thread constructor failed");
 }
 
 #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());
+    int __ec = __libcpp_support::__os_create_thread(&__t_, &__thread_proxy<_Gp>, __p.get());
     if (__ec == 0)
         __p.release();
     else
         __throw_system_error(__ec, "thread constructor failed");
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 

 #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())
     {

 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();}
+void yield() _NOEXCEPT {__libcpp_support::__os_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)
if (NOT IS_DIRECTORY "${LIBDIR}")
       message(FATAL_ERROR "Cannot find compiler-rt directory on OS X required for LLVM_USE_SANITIZER")
     endif()
     set(LIBCXX_SANITIZER_LIBRARY "${LIBDIR}/${LIBFILE}")
     set(LIBCXX_SANITIZER_LIBRARY "${LIBCXX_SANITIZER_LIBRARY}" PARENT_SCOPE)
     message(STATUS "Manually linking compiler-rt library: ${LIBCXX_SANITIZER_LIBRARY}")
     add_library_flags("${LIBCXX_SANITIZER_LIBRARY}")
     add_link_flags("-Wl,-rpath,${LIBDIR}")
   endif()
-endif()
+endif()    
 
 # Generate library list.
 add_library_flags_if(LIBCXX_HAS_PTHREAD_LIB pthread)
 add_library_flags_if(LIBCXX_HAS_C_LIB c)
 add_library_flags_if(LIBCXX_HAS_M_LIB m)
 add_library_flags_if(LIBCXX_HAS_RT_LIB rt)
 add_library_flags_if(LIBCXX_HAS_GCC_S_LIB gcc_s)
 

src/algorithm.cpp

 template bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&);
 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>&);
 
+using namespace __libcpp_support;
 #ifndef _LIBCPP_HAS_NO_THREADS
-static pthread_mutex_t __rs_mut = PTHREAD_MUTEX_INITIALIZER;
+static __os_mutex __rs_mut = __os_mutex_init;
 #endif
 unsigned __rs_default::__c_ = 0;
 
 __rs_default::__rs_default()
 {
 #ifndef _LIBCPP_HAS_NO_THREADS
-    pthread_mutex_lock(&__rs_mut);
+    __os_mutex_lock(&__rs_mut);
 #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);
+        __os_mutex_unlock(&__rs_mut);
 #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
 
+using namespace __libcpp_support;
+
 condition_variable::~condition_variable()
 {
-    pthread_cond_destroy(&__cv_);
+    __os_cond_var_destroy(&__cv_);
 }
 
 void
 condition_variable::notify_one() _NOEXCEPT
 {
-    pthread_cond_signal(&__cv_);
+    __os_cond_var_notify_one(&__cv_);
 }
 
 void
 condition_variable::notify_all() _NOEXCEPT
 {
-    pthread_cond_broadcast(&__cv_);
+    __os_cond_var_notify_all(&__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());
+    int ec = __os_cond_var_wait(&__cv_, lk.mutex()->native_handle());
     if (ec)
         __throw_system_error(ec, "condition_variable wait failed");
 }
 
 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");
+    __os_cond_var_timed_wait(&__cv_, 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

 {
     return 0;
 }
 
 #endif  // _LIBCPP_NO_RTTI
 
 #if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
 
+using namespace __libcpp_support;
 static const std::size_t __sp_mut_count = 16;
-static pthread_mutex_t mut_back_imp[__sp_mut_count] =
+static __os_mutex 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
+    __os_mutex_init, __os_mutex_init, __os_mutex_init, __os_mutex_init,
+    __os_mutex_init, __os_mutex_init, __os_mutex_init, __os_mutex_init,
+    __os_mutex_init, __os_mutex_init, __os_mutex_init, __os_mutex_init,
+    __os_mutex_init, __os_mutex_init, __os_mutex_init, __os_mutex_init
 };
 
 static mutex* mut_back = reinterpret_cast<std::mutex*>(mut_back_imp);
 
 _LIBCPP_CONSTEXPR __sp_mut::__sp_mut(void* p) _NOEXCEPT
    : __lx(p)
 {
 }

src/mutex.cpp

 //===------------------------- 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.
 //
 //===----------------------------------------------------------------------===//
 
 #define _LIBCPP_BUILDING_MUTEX
 #include "mutex"
 #include "limits"
 #include "system_error"
 #include "cassert"
-#include "include/atomic_support.h"
+#include "support/thread.h"
 
 _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 = {};
 
+using namespace __libcpp_support;
+
 mutex::~mutex()
 {
-    pthread_mutex_destroy(&__m_);
+    __os_mutex_destroy(&__m_);
 }
 
 void
 mutex::lock()
 {
-    int ec = pthread_mutex_lock(&__m_);
+    int ec = __os_mutex_lock(&__m_);
     if (ec)
         __throw_system_error(ec, "mutex lock failed");
 }
 
 bool
 mutex::try_lock() _NOEXCEPT
 {
-    return pthread_mutex_trylock(&__m_) == 0;
+    return __os_mutex_trylock(&__m_) == 0;
 }
 
 void
 mutex::unlock() _NOEXCEPT
 {
-    int ec = pthread_mutex_unlock(&__m_);
+    int ec = __os_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");
+    __os_recursive_mutex_init(&__m_);
 }
 
 recursive_mutex::~recursive_mutex()
 {
-    int e = pthread_mutex_destroy(&__m_);
+    int e = __os_recursive_mutex_destroy(&__m_);
     (void)e;
     assert(e == 0);
 }
 
 void
 recursive_mutex::lock()
 {
-    int ec = pthread_mutex_lock(&__m_);
+    int ec = __os_recursive_mutex_lock(&__m_);
     if (ec)
         __throw_system_error(ec, "recursive_mutex lock failed");
 }
 
 void
 recursive_mutex::unlock() _NOEXCEPT
 {
-    int e = pthread_mutex_unlock(&__m_);
+    int e = __os_recursive_mutex_unlock(&__m_);
     (void)e;
     assert(e == 0);
 }
 
 bool
 recursive_mutex::try_lock() _NOEXCEPT
 {
-    return pthread_mutex_trylock(&__m_) == 0;
+    return __os_recursive_mutex_trylock(&__m_) == 0;
 }
 
 // timed_mutex
 
 timed_mutex::timed_mutex()
     : __locked_(false)
 {
 }

 recursive_timed_mutex::~recursive_timed_mutex()
 {
     lock_guard<mutex> _(__m_);
 }
 
 void
 recursive_timed_mutex::lock()
 {
-    pthread_t id = pthread_self();
+    __os_thread_id id = __os_get_current_thread_id();
     unique_lock<mutex> lk(__m_);
-    if (pthread_equal(id, __id_))
+    if (__os_thread_id_compare(id, __id_) == 0)
     {
         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();
+    __os_thread_id id = __os_get_current_thread_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 || __os_thread_id_compare(id, __id_) == 0))
     {
         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;
         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
-
+void __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
+    __libcpp_support::__os_call_once(flag, arg, func);
 }
 
 _LIBCPP_END_NAMESPACE_STD

src/support/pthread/condition_variable.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"
+
+#include <chrono>
+#include "system_error"
+#define _LIBCPP_INCLUDE_THREAD_API
+#include <support/pthread/condition_variable.h>
+#undef _LIBCPP_INCLUDE_THREAD_API
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+namespace __libcpp_support
+{
+
+void __os_cond_var_timed_wait(__os_cond_var* cv,
+     __os_mutex* m,
+     chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
+{
+    using namespace 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, m, &ts);
+    if (ec != 0 && ec != ETIMEDOUT)
+        __throw_system_error(ec, "condition_variable timed_wait failed");    
+}
+
+} //namespace __libcpp_support
+
+#endif // _LIBCPP_HAS_NO_THREADS
+_LIBCPP_END_NAMESPACE_STD

src/support/pthread/mutex.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"
+
+#include <chrono>
+#include <system_error>
+#include "../../include/atomic_support.h"
+
+#define _LIBCPP_INCLUDE_THREAD_API
+#include <support/pthread/mutex.h>
+#undef _LIBCPP_INCLUDE_THREAD_API
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+namespace __libcpp_support
+{
+
+void __os_recursive_mutex_init(__os_mutex* __m)
+{
+    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");
+}
+
+#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
+__os_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 __libcpp_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"
+
+#include <ostream>
+#include <chrono>
+#define _LIBCPP_INCLUDE_THREAD_API
+#include <support/pthread/thread.h>
+#undef _LIBCPP_INCLUDE_THREAD_API
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+namespace __libcpp_support
+{
+
+void
+__os_sleep_for(const chrono::nanoseconds& ns)
+{
+    using namespace chrono;
+    if (ns > nanoseconds::zero())
+    {
+        seconds s = duration_cast<seconds>(ns);
+        timespec ts;
+        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)>((ns-s).count());
+        }
+        else
+        {
+            ts.tv_sec = ts_sec_max;
+            ts.tv_nsec = giga::num - 1;
+        }
+
+        while (nanosleep(&ts, &ts) == -1 && errno == EINTR)
+            ;
+    }
+}
+
+} //namespace __libcpp_support
+
+#endif // _LIBCPP_HAS_NO_THREADS
+_LIBCPP_END_NAMESPACE_STD

src/thread.cpp

 #pragma weak pthread_create // Do not create libpthread dependency
 #endif
 #if defined(_WIN32)
 #include <windows.h>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+using namespace __libcpp_support;
+
 thread::~thread()
 {
     if (__t_ != 0)
         terminate();
 }
 
 void
 thread::join()
 {
-    int ec = pthread_join(__t_, 0);
+    int ec = __os_thread_join(__t_);
 #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_);
+        ec = __os_thread_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
 }

 #   endif
     return 0;  // Means not computable [thread.thread.static]
 #endif  // defined(CTL_HW) && defined(HW_NCPU)
 }
 
 namespace this_thread
 {
 
-void
-sleep_for(const chrono::nanoseconds& ns)
-{
-    using namespace chrono;
-    if (ns > nanoseconds::zero())
-    {
-        seconds s = duration_cast<seconds>(ns);
-        timespec ts;
-        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)>((ns-s).count());
-        }
-        else
-        {
-            ts.tv_sec = ts_sec_max;
-            ts.tv_nsec = giga::num - 1;
-        }
+void sleep_for(const chrono::nanoseconds& ns)
+    __libcpp_support::__os_sleep_for(ns);
 
-        while (nanosleep(&ts, &ts) == -1 && errno == EINTR)
-            ;
-    }
 }
-
-}  // this_thread
-
 __thread_specific_ptr<__thread_struct>&
 __thread_local_data()
 {
     static __thread_specific_ptr<__thread_struct> __p;
     return __p;
 }
 
 // __thread_struct_imp