[libcxx] Threading support: Externalize hardware_concurrency()

[rmaprath]

Summary

Another one of those platform-dependent methods which should live behind the threading API.

[rmaprath]

Re-based on trunk.

[rmaprath]

Ping?

[EricWF]

Same comment as D29818

I really don't like this change (and D29818) because they start to include a ton of extra headers, and because they lift complex configuration logic into what should be a very simple header.
These functions are much better suited to being define out-of-line for a number of reasons.

Is there another way we can allow "external implementations" of these functions without lifting everything into a header?

[rmaprath]

Different take on the patch: Externalize this function only for the externally-thread-api variant.

This is much less intrusive. Note that I haven't added the declaration of __libcpp_thread_hw_concurrency() into __threading_support because it doesn't belong there (needs to be provided through a custom __external_threading header instead).

There is no easy way to test this apart from building an actual external-thread-api libc++ variant. We could do some form of testing with the external-thread-library configuration, but it still requires some not-so-pretty changes that is probably best avoided.

[rmaprath]

@EricWF: Ping?

include/__threading_support

 
 #if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
 # include <__external_threading>
 #elif !defined(_LIBCPP_HAS_NO_THREADS)
 
 #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
 # include <pthread.h>
 # include <sched.h>
+
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+# include <sys/param.h>
+# if defined(BSD)
+#   include <sys/sysctl.h>
+# endif // defined(BSD)
+# include <unistd.h>
+#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+
+#if defined(__NetBSD__)
+#pragma weak pthread_create // Do not create libpthread dependency
+#endif
+
 #elif defined(_LIBCPP_HAS_THREAD_API_WIN32)
 #include <Windows.h>
 #include <process.h>
 #include <fibersapi.h>
 #endif
 
 #if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \
     defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL)

 int __libcpp_thread_detach(__libcpp_thread_t *__t);
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 void __libcpp_thread_yield();
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 void __libcpp_thread_sleep_for(const chrono::nanoseconds& ns);
 
+_LIBCPP_THREAD_ABI_VISIBILITY
+int __libcpp_thread_hw_concurrency();
+
 // Thread local storage
 _LIBCPP_THREAD_ABI_VISIBILITY
 int __libcpp_tls_create(__libcpp_tls_key* __key,
                         void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*));
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 void *__libcpp_tls_get(__libcpp_tls_key __key);
 

    {
      __ts.tv_sec = __ts_sec_max;
      __ts.tv_nsec = 999999999; // (10^9 - 1)
    }
 
    while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR);
 }
 
+int __libcpp_thread_hw_concurrency()
+{
+#if defined(CTL_HW) && defined(HW_NCPU)
+  int __n;
+  int __mib[2] = {CTL_HW, HW_NCPU};
+  std::size_t __sz = sizeof(__n);
+  sysctl(__mib, 2, &__n, &__sz, 0, 0);
+  return __n;
+#elif defined(_SC_NPROCESSORS_ONLN)
+  return sysconf(_SC_NPROCESSORS_ONLN);
+#else  // !(defined(CTL_HW) && defined(HW_NCPU))
+  // TODO: grovel through /proc or check cpuid on x86 and similar
+  // instructions on other architectures.
+# if defined(_LIBCPP_MSVC)
+    _LIBCPP_WARNING("hardware_concurrency not yet implemented")
+# else
+#   warning hardware_concurrency not yet implemented
+# endif
+  return 0;  // Means not computable [thread.thread.static]
+#endif  // defined(CTL_HW) && defined(HW_NCPU
+}
+
 // Thread local storage
 int __libcpp_tls_create(__libcpp_tls_key *__key, void (*__at_exit)(void *))
 {
   return pthread_key_create(__key, __at_exit);
 }
 
 void *__libcpp_tls_get(__libcpp_tls_key __key)
 {

 void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
 {
   using namespace chrono;
   // round-up to the nearest milisecond
   milliseconds __ms = duration_cast<milliseconds>(__ns + 999999);
   Sleep(__ms.count());
 }
 
+int __libcpp_thread_hw_concurrency()
+{
+  SYSTEM_INFO __info;
+  GetSystemInfo(&__info);
+  return __info.dwNumberOfProcessors;
+}
+
 // Thread Local Storage
 int __libcpp_tls_create(__libcpp_tls_key* __key,
                         void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*))
 {
   *__key = FlsAlloc(__at_exit);
   if (*__key == FLS_OUT_OF_INDEXES)
     return GetLastError();
   return 0;

src/thread.cpp

 #include "__config"
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 #include "thread"
 #include "exception"
 #include "vector"
 #include "future"
 #include "limits"
-#include <sys/types.h>
-
-#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
-# include <sys/param.h>
-# if defined(BSD)
-#   include <sys/sysctl.h>
-# endif // defined(BSD)
-#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
-
-#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
-# include <unistd.h>
-#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
-
-#if defined(__NetBSD__)
-#pragma weak pthread_create // Do not create libpthread dependency
-#endif
-
-#if defined(_LIBCPP_WIN32API)
-#include <windows.h>
-#endif // defined(_LIBCPP_WIN32API)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 thread::~thread()
 {
     if (!__libcpp_thread_isnull(&__t_))
         terminate();
 }
thread::detach()
 
     if (ec)
         __throw_system_error(ec, "thread::detach failed");
 }
 
 unsigned
 thread::hardware_concurrency() _NOEXCEPT
 {
-#if defined(CTL_HW) && defined(HW_NCPU)
-    unsigned n;
-    int mib[2] = {CTL_HW, HW_NCPU};
-    std::size_t s = sizeof(n);
-    sysctl(mib, 2, &n, &s, 0, 0);
-    return n;
-#elif defined(_SC_NPROCESSORS_ONLN)
-    long result = sysconf(_SC_NPROCESSORS_ONLN);
-    // sysconf returns -1 if the name is invalid, the option does not exist or
-    // does not have a definite limit.
-    // if sysconf returns some other negative number, we have no idea
-    // what is going on. Default to something safe.
+    int result = __libcpp_thread_hw_concurrency();
+
+    // Treat negative values as errors. Use a safe default value.
     if (result < 0)
         return 0;
-    return static_cast<unsigned>(result);
-#elif defined(_LIBCPP_WIN32API)
-    SYSTEM_INFO info;
-    GetSystemInfo(&info);
-    return info.dwNumberOfProcessors;
-#else  // defined(CTL_HW) && defined(HW_NCPU)
-    // TODO: grovel through /proc or check cpuid on x86 and similar
-    // instructions on other architectures.
-#   if defined(_LIBCPP_MSVC)
-        _LIBCPP_WARNING("hardware_concurrency not yet implemented")
-#   else
-#       warning hardware_concurrency not yet implemented
-#   endif
-    return 0;  // Means not computable [thread.thread.static]
-#endif  // defined(CTL_HW) && defined(HW_NCPU)
+
+    return result;
 }
 
 namespace this_thread
 {
 
 void
 sleep_for(const chrono::nanoseconds& ns)
 {