[Threading] Create new threading library and use it.

Moved all the threading code to one place.  Added explicit support for
Darwin, Linux, Pthreads, C11 threads and Win32 threads, including new
implementations of Once for Linux, Pthreads, C11 and Win32.

rdar://90776105

Author: al45tair

CMakeLists.txt

@@ -126,12 +126,13 @@ option(SWIFT_STDLIB_ENABLE_UNICODE_DATA
 
 include(Threading)
 
-threading_package_default(SWIFT_STDLIB_THREADING_PACKAGE_default)
+threading_package_default("${SWIFT_HOST_VARIANT_SDK}"
+  SWIFT_THREADING_PACKAGE_default)
 
-set(SWIFT_STDLIB_THREADING_PACKAGE "${SWIFT_STDLIB_THREADING_PACKAGE_default}"
+set(SWIFT_THREADING_PACKAGE "${SWIFT_THREADING_PACKAGE_default}"
     CACHE STRING
     "The threading package to use.  Must be one of 'none', 'pthreads',
-    'darwin', 'win32', 'c11'.")
+    'darwin', 'linux', 'win32', 'c11'.")
 
 option(SWIFT_BUILD_DYNAMIC_SDK_OVERLAY
     "Build dynamic variants of the Swift SDK overlay"
@@ -1046,7 +1047,7 @@ if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
   message(STATUS "  Leak Detection Checker Entrypoints: ${SWIFT_RUNTIME_ENABLE_LEAK_CHECKER}")
   message(STATUS "")
 
-  message(STATUS "Threading Package:                  ${SWIFT_STDLIB_THREADING_PACKAGE}")
+  message(STATUS "Threading Package:                  ${SWIFT_THREADING_PACKAGE}")
   message(STATUS "Differentiable Programming Support: ${SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING}")
   message(STATUS "Concurrency Support:                ${SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY}")
   message(STATUS "Distributed Support:                ${SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED}")

cmake/modules/AddSwift.cmake

@@ -4,6 +4,7 @@ include(SwiftXcodeSupport)
 include(SwiftWindowsSupport)
 include(SwiftAndroidSupport)
 include(SwiftCXXUtils)
+include(Threading)
 
 function(_swift_gyb_target_sources target scope)
   file(GLOB GYB_UNICODE_DATA ${SWIFT_SOURCE_DIR}/utils/UnicodeData/*)
@@ -308,6 +309,10 @@ function(_add_host_variant_c_compile_flags target)
       $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS>)
   endif()
 
+  threading_package_name("${SWIFT_HOST_VARIANT_SDK}" _threading_package)
+  target_compile_definitions(${target} PRIVATE
+    "SWIFT_THREADING_${_threading_package}")
+
   if(SWIFT_ANALYZE_CODE_COVERAGE)
     target_compile_options(${target} PRIVATE
       $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:-fprofile-instr-generate -fcoverage-mapping>)

cmake/modules/AddSwiftUnittests.cmake

@@ -49,14 +49,14 @@ function(add_swift_unittest test_dirname)
 
   # some headers switch their inline implementations based on
   # SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY and
-  # SWIFT_STDLIB_THREADING_PACKAGE definitions
+  # SWIFT_THREADING_PACKAGE definitions
   if(SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY)
     target_compile_definitions("${test_dirname}" PRIVATE
       SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY)
   endif()
-  threading_package_name(_threading_package)
+  threading_package_name("${SWIFT_HOST_VARIANT_SDK}" _threading_package)
   target_compile_definitions("${test_dirname}" PRIVATE
-    "SWIFT_STDLIB_THREADING_${_threading_package}")
+    "SWIFT_THREADING_${_threading_package}")
 
   if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
     if(SWIFT_USE_LINKER)

cmake/modules/Threading.cmake

@@ -1,10 +1,12 @@
 # Get the default threading package for the platform
-function(threading_package_default out_var)
-    if("${SWIFT_HOST_VARIANT_SDK}" IN_LIST SWIFT_DARWIN_PLATFORMS)
+function(threading_package_default sdk out_var)
+    if(sdk IN_LIST SWIFT_DARWIN_PLATFORMS)
       set("${out_var}" "darwin" PARENT_SCOPE)
-    elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "WINDOWS")
+    elseif(sdk STREQUAL "LINUX")
+      set("${out_var}" "linux" PARENT_SCOPE)
+    elseif(sdk STREQUAL "WINDOWS")
       set("${out_var}" "win32" PARENT_SCOPE)
-    elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "WASI")
+    elseif(sdk STREQUAL "WASI")
       set("${out_var}" "none" PARENT_SCOPE)
     else()
       set("${out_var}" "pthreads" PARENT_SCOPE)
@@ -14,11 +16,11 @@ endfunction()
 # Given the threading package, find the name for the preprocessor
 # define that we need to make.  Also deals with the default platform
 # setting.
-function(threading_package_name out_var)
+function(threading_package_name sdk out_var)
   precondition(SWIFT_HOST_VARIANT_SDK)
   precondition(SWIFT_DARWIN_PLATFORMS)
 
-  string(TOUPPER "${SWIFT_STDLIB_THREADING_PACKAGE}" package)
+  string(TOUPPER "${SWIFT_THREADING_PACKAGE}" package)
   if(package STREQUAL "")
     threading_package_default(package)
     string(TOUPPER "${package}" package)

include/swift/Basic/Compiler.h

@@ -162,4 +162,20 @@
 #define SWIFT_ASM_LABEL_WITH_PREFIX(STRING) \
   SWIFT_ASM_LABEL_RAW(SWIFT_SYMBOL_PREFIX_STRING STRING)
 
+// SWIFT_FORMAT(fmt,first) marks a function as taking a format string argument
+// at argument `fmt`, with the first argument for the format string as `first`.
+#if __has_attribute(format)
+#define SWIFT_FORMAT(fmt,first) __attribute__((format(printf, fmt, first)))
+#else
+#define SWIFT_FORMAT(fmt,first)
+#endif
+
+// SWIFT_VFORMAT(fmt) marks a function as taking a format string argument at
+// argument `fmt`, with the arguments in a `va_list`.
+#if __has_attribute(format)
+#define SWIFT_VFORMAT(fmt)      __attribute__((format(printf, fmt, 0)))
+#else
+#define SWIFT_VFORMAT(fmt)
+#endif
+
 #endif // SWIFT_BASIC_COMPILER_H

include/swift/Basic/Lazy.h

@@ -15,55 +15,26 @@
 
 #include <memory>
 
-#if SWIFT_STDLIB_THREADING_NONE
-// No dependencies on single-threaded environments.
-#elif SWIFT_STDLIB_THREADING_DARWIN
-#include <dispatch/dispatch.h>
-#else
-#include <mutex>
-#endif
-
 #include "swift/Basic/Malloc.h"
 #include "swift/Basic/type_traits.h"
+#include "swift/Threading/Once.h"
 
 namespace swift {
 
-#if SWIFT_STDLIB_THREADING_NONE
-  using OnceToken_t = bool;
-# define SWIFT_ONCE_F(TOKEN, FUNC, CONTEXT) \
-  do { if (!TOKEN) { TOKEN = true; (FUNC)(CONTEXT); } } while (0)
-#elif SWIFT_STDLIB_THREADING_DARWIN
-  using OnceToken_t = ::dispatch_once_t;
-# define SWIFT_ONCE_F(TOKEN, FUNC, CONTEXT) \
-  ::dispatch_once_f(&TOKEN, CONTEXT, FUNC)
-#elif defined(__CYGWIN__)
-  // _swift_once_f() is declared in Private.h.
-  // This prototype is copied instead including the header file.
-  void _swift_once_f(uintptr_t *predicate, void *context,
-                     void (*function)(void *));
-  using OnceToken_t = unsigned long;
-# define SWIFT_ONCE_F(TOKEN, FUNC, CONTEXT) \
-  _swift_once_f(&TOKEN, CONTEXT, FUNC)
-#else
-  using OnceToken_t = std::once_flag;
-# define SWIFT_ONCE_F(TOKEN, FUNC, CONTEXT) \
-  ::std::call_once(TOKEN, FUNC, CONTEXT)
-#endif
-
 /// A template for lazily-constructed, zero-initialized, leaked-on-exit
 /// global objects.
 template <class T> class Lazy {
   alignas(T) char Value[sizeof(T)] = { 0 };
 
-  OnceToken_t OnceToken = {};
+  swift::once_t OnceToken = {};
 
   static void defaultInitCallback(void *ValueAddr) {
     ::new (ValueAddr) T();
   }
-  
+
 public:
   using Type = T;
-  
+
   T &get(void (*initCallback)(void *) = defaultInitCallback);
 
   template<typename Arg1>
@@ -87,7 +58,7 @@ template <typename T> inline T &Lazy<T>::get(void (*initCallback)(void*)) {
   static_assert(std::is_literal_type<Lazy<T>>::value,
                 "Lazy<T> must be a literal type");
 
-  SWIFT_ONCE_F(OnceToken, initCallback, &Value);
+  swift::once(OnceToken, initCallback, &Value);
   return unsafeGetAlreadyInitialized();
 }
 
@@ -103,7 +74,7 @@ template <typename Arg1> inline T &Lazy<T>::getWithInit(Arg1 &&arg1) {
     }
   } data{&Value, static_cast<Arg1&&>(arg1)};
 
-  SWIFT_ONCE_F(OnceToken, &Data::init, &data);
+  swift::once(OnceToken, &Data::init, &data);
   return unsafeGetAlreadyInitialized();
 }
 

include/swift/Runtime/AtomicWaitQueue.h

@@ -21,7 +21,7 @@
 
 #include "swift/Runtime/Heap.h"
 #include "swift/Runtime/HeapObject.h"
-#include "swift/Runtime/Mutex.h"
+#include "swift/Threading/Mutex.h"
 #include <assert.h>
 
 namespace swift {

include/swift/Runtime/Concurrent.h

@@ -21,7 +21,7 @@
 #include "llvm/Support/Allocator.h"
 #include "Atomic.h"
 #include "Debug.h"
-#include "Mutex.h"
+#include "swift/Threading/Mutex.h"
 
 #if defined(__FreeBSD__) || defined(__CYGWIN__) || defined(__HAIKU__)
 #include <stdio.h>
@@ -624,7 +624,7 @@ using llvm::hash_value;
 /// process. It has no destructor, to avoid generating useless global destructor
 /// calls. The memory it allocates can be freed by calling clear() with no
 /// outstanding readers, but this won't destroy the static mutex it uses.
-template <class ElemTy, class MutexTy = StaticMutex>
+template <class ElemTy, class MutexTy = LazyMutex>
 struct ConcurrentReadableHashMap {
   // We don't call destructors. Make sure the elements will put up with this.
   static_assert(std::is_trivially_destructible<ElemTy>::value,
@@ -1171,7 +1171,7 @@ template <class ElemTy> struct HashMapElementWrapper {
 /// by allocating them separately and storing pointers to them. The elements of
 /// the hash table are instances of HashMapElementWrapper. A new getOrInsert
 /// method is provided that directly returns the stable element pointer.
-template <class ElemTy, class Allocator, class MutexTy = StaticMutex>
+template <class ElemTy, class Allocator, class MutexTy = LazyMutex>
 struct StableAddressConcurrentReadableHashMap
     : public ConcurrentReadableHashMap<HashMapElementWrapper<ElemTy>, MutexTy> {
   // Implicitly trivial destructor.

include/swift/Runtime/Config.h

@@ -232,22 +232,6 @@ extern uintptr_t __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTL
 // so changing this value is not sufficient.
 #define SWIFT_DEFAULT_LLVM_CC llvm::CallingConv::C
 
-// SWIFT_FORMAT(fmt,first) marks a function as taking a format string argument
-// at argument `fmt`, with the first argument for the format string as `first`.
-#if __has_attribute(format)
-#define SWIFT_FORMAT(fmt,first) __attribute__((format(printf, fmt, first)))
-#else
-#define SWIFT_FORMAT(fmt,first)
-#endif
-
-// SWIFT_VFORMAT(fmt) marks a function as taking a format string argument at
-// argument `fmt`, with the arguments in a `va_list`.
-#if __has_attribute(format)
-#define SWIFT_VFORMAT(fmt)      __attribute__((format(printf, fmt, 0)))
-#else
-#define SWIFT_VFORMAT(fmt)
-#endif
-
 /// Should we use absolute function pointers instead of relative ones?
 /// WebAssembly target uses it by default.
 #ifndef SWIFT_COMPACT_ABSOLUTE_FUNCTION_POINTER

include/swift/Runtime/EnvironmentVariables.h

@@ -14,15 +14,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "../Basic/Lazy.h"
+#include "swift/Threading/Once.h"
 
 namespace swift {
 namespace runtime {
 namespace environment {
 
 void initialize(void *);
 
-extern OnceToken_t initializeToken;
+extern swift::once_t initializeToken;
 
 // Declare backing variables.
 #define VARIABLE(name, type, defaultValue, help) extern type name ## _variable;
@@ -31,7 +31,7 @@ extern OnceToken_t initializeToken;
 // Define getter functions.
 #define VARIABLE(name, type, defaultValue, help)        \
   inline type name() {                                  \
-    SWIFT_ONCE_F(initializeToken, initialize, nullptr); \
+    swift::once(initializeToken, initialize, nullptr);  \
     return name ## _variable;                           \
   }
 #include "../../../stdlib/public/runtime/EnvironmentVariables.def"