[libc++] Allow libc++ to be built on systems without POSIX threads

[joerg]

I'm not sure I like the name _LIBCPP_SINGLE_THREADED, especially since it is pretty much exclusively used in the negative sense. Otherwise fine with me.

sources/cxx-stl/llvm-libc++/libcxx/include/__config

124

#if _POSIX_THREADS - 0 > 0

might be simpler

[jroelofs]

I picked the name to match the one I recently added to libc++abi. I'm open to suggestions though.

The other one I considered was _LIBCPP_HAS_POSIX_THREADS, but that seemed to be less fitting (one could have a system with pthreads, but still not want to build libc++ with threads enabled, for example).

sources/cxx-stl/llvm-libc++/libcxx/include/__config

124

Is there much of a precedent either way? I haven't seen any laid out like that...

[mclow.lists]

In general, libc++ uses the negative for missing capabilities.
_LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_HAS_NO_ADVANCED_SFINAE
_LIBCPP_HAS_NO_VARIADICS
_LIBCPP_HAS_NO_TRAILING_RETURN

I would prefer to keep this convention.

[mclow.lists]

I would also like to understand more about the motivation behind this patch.
Concurrency is a core part of C++11library, and just disabling it seems wrong to me.

I know there are systems w/o POSIX threads, but to support those systems, libc++ should use whatever primitives exist there, rather than just disabling all the threading support.

What are you trying to accomplish here?

[jroelofs]

mclow, the motivation for this is for bare-metal systems where we don't have threads. I suppose my title for this left a little too much room to read into it.

The other alternative would be to write no-op shims around all of these primitives, but that seems like it would be a lot of mess for very little benefit.

sources/cxx-stl/llvm-libc++/libcxx/include/shared_mutex

419

line should read:

#endif // !_LIBCPP_SINGLE_THREADED

sources/cxx-stl/llvm-libc++/libcxx/src/memory.cpp

175

line should read:

#endif // __has_feature(cxx_atomic) && !_LIBCPP_SINGLE_THREADED

[jroelofs]

sources/cxx-stl/llvm-libc++/libcxx/include/__mutex_base

53

awong pointed out that it makes sense to exclude defer_lock_t and friends also,

so delete this line....

269

... and this one.

[jroelofs]

sources/cxx-stl/llvm-libc++/libcxx/include/__config

14

awong also suggested that I wrap this in an #if !_WIN32.

[joerg]

What is the status of this patch?

[jroelofs]

sources/cxx-stl/llvm-libc++/libcxx/src/thread.cpp

129

This ought to get moved to http://reviews.llvm.org/D4045 (i.e. place sleep_for inside a _LIBCPP_HAS_MONOTONIC_CLOCK)

[jroelofs]

Hi Joerg,

I'm finally resurrecting this...

[jroelofs]

Renamed according to mclow's suggestion: s/_LIBCPP_SINGLE_THREADED/_LIBCPP_HAS_NO_THREADS/

[jroelofs]

Fix a couple of typos I just caught.

[jroelofs]

Ping

[mclow.lists]

See the inline comments; I think that _LIBCPP_HAS_NO_THREADS should be defined when building single-threaded, and not defined otherwise (that would match the rest of the libc++ config macros).

Also, aren't there a bunch of tests that are going to need to change?

include/__config

126 ↗

(On Diff #12456)

This should be wrapped in an "#ifndef _LIBCPP_HAS_NO_THREADS" block, and should just define it, rather than give it a 0/1 value.

This will allow someone to build an "no threads" version of libcpp by -D _LIBCPP_HAS_NO_THREADS on the command line.

include/__mutex_base

25 ↗

(On Diff #12456)

this should just be #ifndef _LIBCPP_HAS_NO_THREADS

33 ↗

(On Diff #12456)

Whitespace change?

[jroelofs]

I have another set of patches for the tests that this affects. Should I merge them all and include them here?

include/__config

126 ↗

(On Diff #12456)

Wait, do you mean that this hunk should just go away? Or do you mean that it should be:

#if !defined(_LIBCPP_HAS_NO_THREADS) && defined(_POSIX_THREADS) && _POSIX_THREADS > 0
#define _LIBCPP_HAS_NO_THREADS
#endif

I'm not sure I understand what you're asking for here.

include/__mutex_base

25 ↗

(On Diff #12456)

Ok, I'll change all of them to that style.

33 ↗

(On Diff #12456)

Looks like... I'll get rid of it.

[jroelofs]

Implement a few of mclow's comments.

[jroelofs]

It'll take a bit more to fish out the changes to the tests (mostly adding 'XFAIL: libcxx-single-threaded')

include/__config

126 ↗

(On Diff #12803)

@mclow earlier you suggested having just the build define this with -D_LIBCPP_HAS_NO_THREADS. I thought adding this as a error/warning might be nice.

Another thing I've just realized: if this is only set during the build, then how to I arrange for it to be set in an installed system? I don't want my users to have to -D_LIBCPP_HAS_NO_THREADS whenever they want to use libcxx.

include/thread

110 ↗

(On Diff #12803)

s/system/single threaded system/

src/thread.cpp

33 ↗

(On Diff #12803)

un-necessary whitespace change

[jroelofs]

Fix a whiltespace issue, and re-word an error message.

[jroelofs]

XFAILS for this are here: http://reviews.llvm.org/D5013

I didn't add any of the lists as a subscriber as this diff is rather large and mechanical.

In summary it adds "// XFAIL: libcxx-single-threaded" to all of the tests which this "breaks".

[EricWF]

src/mutex.cpp

224–233 ↗

(On Diff #12804)

Wouldn't it be a lot cleaner to just separate the two implementation entirely instead of interweaving them like this?

[jroelofs]

src/mutex.cpp

224–233 ↗

(On Diff #12804)

Sigh. Yes. *hits head on desk*. Why did I do it like that?

[jroelofs]

include/memory

615 ↗

(On Diff #12804)

I missed a pair of changes in this file. The __has_feature(cxx_atomic) #ifdef block needs to be:

#if __has_feature(cxx_atomic) && !defined(_LIBCXX_HAS_NO_THREADS)
...
#endif  // __has_feature(cxx_atomic) && !defined(_LIBCXX_HAS_NO_THREADS)

I also missed a pair of these in include/ios near lines 216 and 367

[jroelofs]

Separate out the two halves of __call_once as per EricWF's suggestion, and address my own review comment (about having forgotten a section).

[danalbert]

I'm a little bit worried about the no-threads build bit-rotting (if any of us forget to wrap something in #ifndef _LIBCPP_HAS_NO_THREADS). Should we have a buildbot set up to build this configuration? Would it be possible to define noop implementations of all the things you've ifdef'd out so that we don't have to worry about that? It's possible that would make things more or a mess, but I'm not sure.

src/condition_variable.cpp

19 ↗

(On Diff #13079)

nit

[danalbert]

From email thread:

Should we have a buildbot set up to build this configuration?

I would appreciate having one, but I can't host it at the moment.
At some point I would like to host a baremetal buildbot (targeting either QEMU, a raspberry pi, or some beagleboard), but I'm not quite ready for that... we need to work out the details of remote testing in lit before that is practical.

Keeping a buildbot going for this patch doesn't actually require baremetal (though that would be nice to have as well). @EricWF recently set up a buildbot. He might be willing to host it.

Would it be possible to define noop implementations of all the things you've ifdef'd out so that we don't have to worry about that? It's possible that would make things more or a mess, but I'm not sure.

I think that nop-shims have an even higher potential for bit-rot than these #ifdef's.
I originally attempted writing no-op shims for a few of them, but there were several where it didn't seem possible, and others where the shims were pretty hairy.

Okay, I thought that might be the case.

With those things accounted for, LGTM.

[jroelofs]

Fix a couple of nits, and add in the XFAILs as UNSUPPORTEDs.

[jroelofs]

Oh, and I also removed the autodetect part of include/__config

[jroelofs]

r217271

sources/cxx-stl/llvm-libc++/libcxx/include/__config

 // -*- C++ -*-
 //===--------------------------- __config ---------------------------------===//
 //
 //                     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_CONFIG
 #define _LIBCPP_CONFIG
 
+#include <unistd.h>
+
 #if !defined(_MSC_VER) || defined(__clang__)
 #pragma GCC system_header
 #endif
 
 #ifdef __GNUC__
 #define _GNUC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
 #endif
 

 # elif __BYTE_ORDER == __BIG_ENDIAN
 #  define _LIBCPP_LITTLE_ENDIAN 0
 #  define _LIBCPP_BIG_ENDIAN    1
 # else  // __BYTE_ORDER == __BIG_ENDIAN
 #  error unable to determine endian
 # endif
 #endif  // !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
 
+#if defined(_POSIX_THREADS) && _POSIX_THREADS > 0
+#  define _LIBCPP_SINGLE_THREADED 0
+#else
+#  define _LIBCPP_SINGLE_THREADED 1
+#endif
+
 #ifdef _WIN32
 
 // only really useful for a DLL
 #ifdef _LIBCPP_DLL // this should be a compiler builtin define ideally...
 # ifdef cxx_EXPORTS
 #  define _LIBCPP_HIDDEN
 #  define _LIBCPP_FUNC_VIS __declspec(dllexport)
 #  define _LIBCPP_TYPE_VIS __declspec(dllexport)

sources/cxx-stl/llvm-libc++/libcxx/include/__mutex_base

 #include <pthread.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if !_LIBCPP_SINGLE_THREADED
+
 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_;}
 };
+#endif // !_LIBCPP_SINGLE_THREADED
 
 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)
 
+#if !_LIBCPP_SINGLE_THREADED
 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
public:
 
     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_SINGLE_THREADED
 
 template <class _To, class _Rep, class _Period>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     chrono::__is_duration<_To>::value,
     _To
 >::type
 __ceil(chrono::duration<_Rep, _Period> __d)
 {
     using namespace chrono;
     _To __r = duration_cast<_To>(__d);
     if (__r < __d)
         ++__r;
     return __r;
 }
 
+#if !_LIBCPP_SINGLE_THREADED
 template <class _Predicate>
 void
 condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
 {
     while (!__pred())
         wait(__lk);
 }
 

 condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d,
                              _Predicate __pred)
 {
     return wait_until(__lk, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
+#endif // !_LIBCPP_SINGLE_THREADED
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP___MUTEX_BASE

sources/cxx-stl/llvm-libc++/libcxx/include/condition_variable

 #include <__config>
 #include <__mutex_base>
 #include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if !_LIBCPP_SINGLE_THREADED
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS condition_variable_any
 {
     condition_variable __cv_;
     shared_ptr<mutex>  __mut_;
 public:
     condition_variable_any();
return wait_until(__lock, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
 _LIBCPP_FUNC_VIS
 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // !_LIBCPP_SINGLE_THREADED
+
 #endif  // _LIBCPP_CONDITION_VARIABLE

sources/cxx-stl/llvm-libc++/libcxx/include/future

 #include <exception>
 #include <mutex>
 #include <thread>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if !_LIBCPP_SINGLE_THREADED
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 //enum class future_errc
 _LIBCPP_DECLARE_STRONG_ENUM(future_errc)
 {
     future_already_retrieved = 1,
     promise_already_satisfied,
     no_state,

 {
     return shared_future<void>(_VSTD::move(*this));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // !_LIBCPP_SINGLE_THREADED
+
 #endif  // _LIBCPP_FUTURE

sources/cxx-stl/llvm-libc++/libcxx/include/mutex

 #include <__undef_min_max>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if !_LIBCPP_SINGLE_THREADED
+
 class _LIBCPP_TYPE_VIS recursive_mutex
 {
     pthread_mutex_t __m_;
 
 public:
      recursive_mutex();
      ~recursive_mutex();
 

 void
 lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 {
     __lock_first(0, __l0, __l1, __l2, __l3...);
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
+#endif // !_LIBCPP_SINGLE_THREADED
+
 struct _LIBCPP_TYPE_VIS once_flag;
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template<class _Callable, class... _Args>
 _LIBCPP_INLINE_VISIBILITY
 void call_once(once_flag&, _Callable&&, _Args&&...);
 

sources/cxx-stl/llvm-libc++/libcxx/include/shared_mutex

 #include <__mutex_base>
 
 #include <__undef_min_max>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+#if !_LIBCPP_SINGLE_THREADED
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS shared_timed_mutex
 {
     mutex               __mut_;
     condition_variable  __gate1_;
     condition_variable  __gate2_;
     unsigned            __state_;

 template <class _Mutex>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) noexcept
     {__x.swap(__y);}
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif  // _LIBC_HAS_PTHREADS
+
 #endif  // _LIBCPP_STD_VER > 11
 
 #endif  // _LIBCPP_SHARED_MUTEX

sources/cxx-stl/llvm-libc++/libcxx/include/thread

 #include <pthread.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #define __STDCPP_THREADS__ __cplusplus
 
+#if !_LIBCPP_SINGLE_THREADED
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 class __thread_specific_ptr
 {
     pthread_key_t __key_;
 
     __thread_specific_ptr(const __thread_specific_ptr&);

 
 inline _LIBCPP_INLINE_VISIBILITY
 void yield() _NOEXCEPT {sched_yield();}
 
 }  // this_thread
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // !_LIBCPP_SINGLE_THREADED
+
 #endif  // _LIBCPP_THREAD

sources/cxx-stl/llvm-libc++/libcxx/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>&);
 
+#if !_LIBCPP_SINGLE_THREADED
 static pthread_mutex_t __rs_mut = PTHREAD_MUTEX_INITIALIZER;
+#endif
 unsigned __rs_default::__c_ = 0;
 
 __rs_default::__rs_default()
 {
+#if !_LIBCPP_SINGLE_THREADED
     pthread_mutex_lock(&__rs_mut);
+#endif
     __c_ = 1;
 }
 
 __rs_default::__rs_default(const __rs_default&)
 {
     ++__c_;
 }
 
 __rs_default::~__rs_default()
 {
+#if !_LIBCPP_SINGLE_THREADED
     if (--__c_ == 0)
         pthread_mutex_unlock(&__rs_mut);
+#else
+    --__c_;
+#endif
 }
 
 __rs_default::result_type
 __rs_default::operator()()
 {
     static mt19937 __rs_g;
     return __rs_g();
 }
 
 __rs_default
 __rs_get()
 {
     return __rs_default();
 }
 
 _LIBCPP_END_NAMESPACE_STD

sources/cxx-stl/llvm-libc++/libcxx/src/chrono.cpp

 #include <sys/time.h>        //for gettimeofday and timeval
 #ifdef __APPLE__
 #include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
 #else  /* !__APPLE__ */
 #include <cerrno>  // errno
 #include <system_error>  // __throw_system_error
 #include <time.h>  // clock_gettime, CLOCK_MONOTONIC
 #endif  // __APPLE__
+#include <unistd.h>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace chrono
 {
 
 // system_clock
 

sources/cxx-stl/llvm-libc++/libcxx/src/condition_variable.cpp

 //===-------------------- 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 "condition_variable"
 #include "thread"
 #include "system_error"
 #include "cassert"
 
+#if !_LIBCPP_SINGLE_THREADED
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 condition_variable::~condition_variable()
 {
     pthread_cond_destroy(&__cv_);
 }
 
 void

 
 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_SINGLE_THREADED
+

sources/cxx-stl/llvm-libc++/libcxx/src/debug.cpp

 __get_const_db()
 {
     return __get_db();
 }
 
 namespace
 {
 
+#if !_LIBCPP_SINGLE_THREADED
 typedef mutex mutex_type;
 typedef lock_guard<mutex_type> WLock;
 typedef lock_guard<mutex_type> RLock;
 
 mutex_type&
 mut()
 {
     static mutex_type m;
     return m;
 }
+#endif // !_LIBCPP_SINGLE_THREADED
 
 }  // unnamed namespace
 
 __i_node::~__i_node()
 {
     if (__next_)
     {
         __next_->~__i_node();
if (__ibeg_)
         }
         free(__ibeg_);
     }
 }
 
 void*
 __libcpp_db::__find_c_from_i(void* __i) const
 {
+#if !_LIBCPP_SINGLE_THREADED
     RLock _(mut());
+#endif
     __i_node* i = __find_iterator(__i);
     _LIBCPP_ASSERT(i != nullptr, "iterator not found in debug database.");
     return i->__c_ != nullptr ? i->__c_->__c_ : nullptr;
 }
 
 void
 __libcpp_db::__insert_ic(void* __i, const void* __c)
 {
+#if !_LIBCPP_SINGLE_THREADED
     WLock _(mut());
+#endif
     if (__cbeg_ == __cend_)
         return;
     size_t hc = hash<const void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
     __c_node* c = __cbeg_[hc];
     if (c == nullptr)
         return;
     while (c->__c_ != __c)
     {
         c = c->__next_;
         if (c == nullptr)
             return;
     }
     __i_node* i = __insert_iterator(__i);
     c->__add(i);
     i->__c_ = c;
 }
 
 __c_node*
 __libcpp_db::__insert_c(void* __c)
 {
+#if !_LIBCPP_SINGLE_THREADED
     WLock _(mut());
+#endif
     if (__csz_ + 1 > static_cast<size_t>(__cend_ - __cbeg_))
     {
         size_t nc = __next_prime(2*static_cast<size_t>(__cend_ - __cbeg_) + 1);
         __c_node** cbeg = static_cast<__c_node**>(calloc(nc, sizeof(void*)));
         if (cbeg == nullptr)
 #ifndef _LIBCPP_NO_EXCEPTIONS
             throw bad_alloc();
 #else
#endif
     r->__next_ = p;
     ++__csz_;
     return r;
 }
 
 void
 __libcpp_db::__erase_i(void* __i)
 {
+#if !_LIBCPP_SINGLE_THREADED
     WLock _(mut());
+#endif
     if (__ibeg_ != __iend_)
     {
         size_t hi = hash<void*>()(__i) % static_cast<size_t>(__iend_ - __ibeg_);
         __i_node* p = __ibeg_[hi];
         if (p != nullptr)
         {
             __i_node* q = nullptr;
             while (p->__i_ != __i)
if (__ibeg_ != __iend_)
                 c->__remove(p);
         }
     }
 }
 
 void
 __libcpp_db::__invalidate_all(void* __c)
 {
+#if !_LIBCPP_SINGLE_THREADED
     WLock _(mut());
+#endif
     if (__cend_ != __cbeg_)
     {
         size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
         __c_node* p = __cbeg_[hc];
         if (p == nullptr)
             return;
         while (p->__c_ != __c)
         {
             p = p->__next_;
             if (p == nullptr)
                 return;
         }
         while (p->end_ != p->beg_)
         {
             --p->end_;
             (*p->end_)->__c_ = nullptr;
         }
     }
 }
 
 __c_node*
 __libcpp_db::__find_c_and_lock(void* __c) const
 {
+#if !_LIBCPP_SINGLE_THREADED
     mut().lock();
+#endif
     if (__cend_ == __cbeg_)
     {
+#if !_LIBCPP_SINGLE_THREADED
         mut().unlock();
+#endif
         return nullptr;
     }
     size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
     __c_node* p = __cbeg_[hc];
     if (p == nullptr)
     {
+#if !_LIBCPP_SINGLE_THREADED
         mut().unlock();
+#endif
         return nullptr;
     }
     while (p->__c_ != __c)
     {
         p = p->__next_;
         if (p == nullptr)
         {
+#if !_LIBCPP_SINGLE_THREADED
             mut().unlock();
+#endif
             return nullptr;
         }
     }
     return p;
 }
 
 __c_node*
 __libcpp_db::__find_c(void* __c) const
 {
     size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
     __c_node* p = __cbeg_[hc];
     _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c A");
     while (p->__c_ != __c)
     {
         p = p->__next_;
         _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c B");
     }
     return p;
 }
 
 void
 __libcpp_db::unlock() const
 {
+#if !_LIBCPP_SINGLE_THREADED
     mut().unlock();
+#endif
 }
 
 void
 __libcpp_db::__erase_c(void* __c)
 {
+#if !_LIBCPP_SINGLE_THREADED
     WLock _(mut());
+#endif
     if (__cend_ != __cbeg_)
     {
         size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
         __c_node* p = __cbeg_[hc];
         if (p == nullptr)
             return;
         __c_node* q = nullptr;
         _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c A");
if (__cend_ != __cbeg_)
         free(p);
         --__csz_;
     }
 }
 
 void
 __libcpp_db::__iterator_copy(void* __i, const void* __i0)
 {
+#if !_LIBCPP_SINGLE_THREADED
     WLock _(mut());
+#endif
     __i_node* i = __find_iterator(__i);
     __i_node* i0 = __find_iterator(__i0);
     __c_node* c0 = i0 != nullptr ? i0->__c_ : nullptr;
     if (i == nullptr && i0 != nullptr)
         i = __insert_iterator(__i);
     __c_node* c = i != nullptr ? i->__c_ : nullptr;
     if (c != c0)
     {
if (c != c0)
             }
         }
     }
 }
 
 bool
 __libcpp_db::__dereferenceable(const void* __i) const
 {
+#if !_LIBCPP_SINGLE_THREADED
     RLock _(mut());
+#endif
     __i_node* i = __find_iterator(__i);
     return i != nullptr && i->__c_ != nullptr && i->__c_->__dereferenceable(__i);
 }
 
 bool
 __libcpp_db::__decrementable(const void* __i) const
 {
+#if !_LIBCPP_SINGLE_THREADED
     RLock _(mut());
+#endif
     __i_node* i = __find_iterator(__i);
     return i != nullptr && i->__c_ != nullptr && i->__c_->__decrementable(__i);
 }
 
 bool
 __libcpp_db::__addable(const void* __i, ptrdiff_t __n) const
 {
+#if !_LIBCPP_SINGLE_THREADED
     RLock _(mut());
+#endif
     __i_node* i = __find_iterator(__i);
     return i != nullptr && i->__c_ != nullptr && i->__c_->__addable(__i, __n);
 }
 
 bool
 __libcpp_db::__subscriptable(const void* __i, ptrdiff_t __n) const
 {
+#if !_LIBCPP_SINGLE_THREADED
     RLock _(mut());
+#endif
     __i_node* i = __find_iterator(__i);
     return i != nullptr && i->__c_ != nullptr && i->__c_->__subscriptable(__i, __n);
 }
 
 bool
 __libcpp_db::__less_than_comparable(const void* __i, const void* __j) const
 {
+#if !_LIBCPP_SINGLE_THREADED
     RLock _(mut());
+#endif
     __i_node* i = __find_iterator(__i);
     __i_node* j = __find_iterator(__j);
     __c_node* ci = i != nullptr ? i->__c_ : nullptr;
     __c_node* cj = j != nullptr ? j->__c_ : nullptr;
     return ci != nullptr && ci == cj;
 }
 
 void
 __libcpp_db::swap(void* c1, void* c2)
 {
+#if !_LIBCPP_SINGLE_THREADED
     WLock _(mut());
+#endif
     size_t hc = hash<void*>()(c1) % static_cast<size_t>(__cend_ - __cbeg_);
     __c_node* p1 = __cbeg_[hc];
     _LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap A");
     while (p1->__c_ != c1)
     {
         p1 = p1->__next_;
         _LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap B");
     }
for (__i_node** p = p1->beg_; p != p1->end_; ++p)
         (*p)->__c_ = p1;
     for (__i_node** p = p2->beg_; p != p2->end_; ++p)
         (*p)->__c_ = p2;
 }
 
 void
 __libcpp_db::__insert_i(void* __i)
 {
+#if !_LIBCPP_SINGLE_THREADED
     WLock _(mut());
+#endif
     __insert_iterator(__i);
 }
 
 void
 __c_node::__add(__i_node* i)
 {
     if (end_ == cap_)
     {

sources/cxx-stl/llvm-libc++/libcxx/src/future.cpp

 //===------------------------- future.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 "future"
 #include "string"
 
+#if !_LIBCPP_SINGLE_THREADED
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_HIDDEN __future_error_category
     : public __do_message
 {
 public:
     virtual const char* name() const _NOEXCEPT;
     virtual string message(int ev) const;
if (__rhs.__state_)
         __rhs.__state_->__add_shared();
     if (__state_)
         __state_->__release_shared();
     __state_ = __rhs.__state_;
     return *this;
 }
 
 _LIBCPP_END_NAMESPACE_STD
+
+#endif // !_LIBCPP_SINGLE_THREADED
+
+

sources/cxx-stl/llvm-libc++/libcxx/src/memory.cpp

 const void*
 __shared_weak_count::__get_deleter(const type_info&) const _NOEXCEPT
 {
     return 0;
 }
 
 #endif  // _LIBCPP_NO_RTTI
 
-#if __has_feature(cxx_atomic)
+#if __has_feature(cxx_atomic) && !_LIBCPP_SINGLE_THREADED
 
 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 __sp_mut muts[__sp_mut_count]
         &mut_back[ 0], &mut_back[ 1], &mut_back[ 2], &mut_back[ 3],
         &mut_back[ 4], &mut_back[ 5], &mut_back[ 6], &mut_back[ 7],
         &mut_back[ 8], &mut_back[ 9], &mut_back[10], &mut_back[11],
         &mut_back[12], &mut_back[13], &mut_back[14], &mut_back[15]
     };
     return muts[hash<const void*>()(p) & (__sp_mut_count-1)];
 }
 
-#endif // __has_feature(cxx_atomic)
+#endif // __has_feature(cxx_atomic) && LIBCPP_HAS_PTHREADS
 
 void
 declare_reachable(void*)
 {
 }
 
 void
 declare_no_pointers(char*, size_t)

sources/cxx-stl/llvm-libc++/libcxx/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"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+#if !_LIBCPP_SINGLE_THREADED
 
 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_);
recursive_timed_mutex::unlock() _NOEXCEPT
     if (--__count_ == 0)
     {
         __id_ = 0;
         lk.unlock();
         __cv_.notify_one();
     }
 }
 
+#endif // !_LIBCPP_SINGLE_THREADED
+
 // 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.
 
+#if !_LIBCPP_SINGLE_THREADED
 static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t  cv  = PTHREAD_COND_INITIALIZER;
+#endif
 
 void
 __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
 {
+#if !_LIBCPP_SINGLE_THREADED
     pthread_mutex_lock(&mut);
     while (flag == 1)
         pthread_cond_wait(&cv, &mut);
+#endif // !_LIBCPP_SINGLE_THREADED
     if (flag == 0)
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             flag = 1;
+#if !_LIBCPP_SINGLE_THREADED
             pthread_mutex_unlock(&mut);
+#endif // !_LIBCPP_SINGLE_THREADED
             func(arg);
+#if !_LIBCPP_SINGLE_THREADED
             pthread_mutex_lock(&mut);
+#endif // !_LIBCPP_SINGLE_THREADED
             flag = ~0ul;
+#if !_LIBCPP_SINGLE_THREADED
             pthread_mutex_unlock(&mut);
             pthread_cond_broadcast(&cv);
+#endif // !_LIBCPP_SINGLE_THREADED
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
+#if !_LIBCPP_SINGLE_THREADED
             pthread_mutex_lock(&mut);
+#endif // !_LIBCPP_SINGLE_THREADED
             flag = 0ul;
+#if !_LIBCPP_SINGLE_THREADED
             pthread_mutex_unlock(&mut);
             pthread_cond_broadcast(&cv);
+#endif // !_LIBCPP_SINGLE_THREADED
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
+#if !_LIBCPP_SINGLE_THREADED
     else
         pthread_mutex_unlock(&mut);
+#endif // !_LIBCPP_SINGLE_THREADED
 }
 
 _LIBCPP_END_NAMESPACE_STD

sources/cxx-stl/llvm-libc++/libcxx/src/shared_mutex.cpp

 //===---------------------- shared_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_SHARED_MUTEX
 #include "shared_mutex"
 
+#if !_LIBCPP_SINGLE_THREADED
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 shared_timed_mutex::shared_timed_mutex()
     : __state_(0)
 {
 }
 
 // Exclusive ownership
shared_timed_mutex::unlock_shared()
     {
         if (num_readers == __n_readers_ - 1)
             __gate1_.notify_one();
     }
 }
 
 
 _LIBCPP_END_NAMESPACE_STD
+
+#endif // !_LIBCPP_SINGLE_THREADED
+
+

sources/cxx-stl/llvm-libc++/libcxx/src/thread.cpp

 
 #if defined(__NetBSD__)
 #pragma weak pthread_create // Do not create libpthread dependency
 #endif
 #if defined(_WIN32)
 #include <windows.h>
 #endif
 
+#if !_LIBCPP_SINGLE_THREADED
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 thread::~thread()
 {
     if (__t_ != 0)
         terminate();
 }
 
if (ns > nanoseconds::zero())
             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;
         }
+#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309L
         nanosleep(&ts, 0);
+#else
+#warning sleep_for not yet implemented
+#endif
     }
 }
 
 }  // this_thread
 
 __thread_specific_ptr<__thread_struct>&
 __thread_local_data()
 {

 
 void
 __thread_struct::__make_ready_at_thread_exit(__assoc_sub_state* __s)
 {
     __p_->__make_ready_at_thread_exit(__s);
 }
 
 _LIBCPP_END_NAMESPACE_STD
+
+#endif // !_LIBCPP_SINGLE_THREADED
+