[BackDeployConcurrency] Fix to use the new threading library.

A copy of the older Concurrency sources was just added to BackDeployConcurrency,
replacing the `add_subdirectory(../Concurrency)` trick it was using previously.
These need to be adjusted to work with the threading library.  Fortunately, the
necessary adjustments are the same as those required for the existing
Concurrency library, give or take.

rdar://90776105

Author: al45tair

stdlib/public/BackDeployConcurrency/Actor.cpp

@@ -17,22 +17,14 @@
 
 #include "ConcurrencyRuntime.h"
 
-#ifdef _WIN32
-// On Windows, an include below triggers an indirect include of minwindef.h
-// which contains a definition of the `max` macro, generating an error in our
-// use of std::max in this file. This define prevents those macros from being
-// defined.
-#define NOMINMAX
-#endif
-
 #include "CompatibilityOverride.h"
+#include "swift/Basic/ListMerger.h"
 #include "swift/Runtime/Atomic.h"
 #include "swift/Runtime/Casting.h"
-#include "swift/Runtime/Once.h"
-#include "swift/Runtime/Mutex.h"
-#include "swift/Runtime/ThreadLocal.h"
-#include "swift/Runtime/ThreadLocalStorage.h"
-#include "swift/Basic/ListMerger.h"
+#include "swift/Threading/Once.h"
+#include "swift/Threading/Mutex.h"
+#include "swift/Threading/Thread.h"
+#include "swift/Threading/ThreadLocalStorage.h"
 #ifndef SWIFT_CONCURRENCY_BACK_DEPLOYMENT
 #include "llvm/Config/config.h"
 #else
@@ -71,19 +63,8 @@
 #include <sys/syscall.h>
 #endif
 
-#if HAVE_PTHREAD_H
-#include <pthread.h>
-
-// Only use __has_include since HAVE_PTHREAD_NP_H is not provided.
-#if __has_include(<pthread_np.h>)
-#include <pthread_np.h>
-#endif
-#endif
-
 #if defined(_WIN32)
 #include <io.h>
-#include <handleapi.h>
-#include <processthreadsapi.h>
 #endif
 
 #if SWIFT_OBJC_INTEROP
@@ -129,9 +110,9 @@ class ExecutorTrackingInfo {
   /// the right executor. It would make sense for that to be a
   /// separate thread-local variable (or whatever is most efficient
   /// on the target platform).
-  static SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(
-      Pointer<ExecutorTrackingInfo>, ActiveInfoInThread,
-      SWIFT_CONCURRENCY_EXECUTOR_TRACKING_INFO_KEY);
+  static SWIFT_THREAD_LOCAL_TYPE(Pointer<ExecutorTrackingInfo>,
+                                 tls_key::concurrency_executor_tracking_info)
+      ActiveInfoInThread;
 
   /// The active executor.
   ExecutorRef ActiveExecutor = ExecutorRef::generic();
@@ -154,7 +135,7 @@ class ExecutorTrackingInfo {
 
   /// Unconditionally initialize a fresh tracking state on the
   /// current state, shadowing any previous tracking state.
-  /// leave() must be called beforet the object goes out of scope.
+  /// leave() must be called before the object goes out of scope.
   void enterAndShadow(ExecutorRef currentExecutor) {
     ActiveExecutor = currentExecutor;
     SavedInfo = ActiveInfoInThread.get();
@@ -197,24 +178,21 @@ class ExecutorTrackingInfo {
 class ActiveTask {
   /// A thread-local variable pointing to the active tracking
   /// information about the current thread, if any.
-  static SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(Pointer<AsyncTask>, Value,
-                                            SWIFT_CONCURRENCY_TASK_KEY);
+  static SWIFT_THREAD_LOCAL_TYPE(Pointer<AsyncTask>,
+                                 tls_key::concurrency_task) Value;
 
 public:
   static void set(AsyncTask *task) { Value.set(task); }
   static AsyncTask *get() { return Value.get(); }
 };
 
 /// Define the thread-locals.
-SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(
-  Pointer<AsyncTask>,
-  ActiveTask::Value,
-  SWIFT_CONCURRENCY_TASK_KEY);
+SWIFT_THREAD_LOCAL_TYPE(Pointer<AsyncTask>, tls_key::concurrency_task)
+ActiveTask::Value;
 
-SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(
-  Pointer<ExecutorTrackingInfo>,
-  ExecutorTrackingInfo::ActiveInfoInThread,
-  SWIFT_CONCURRENCY_EXECUTOR_TRACKING_INFO_KEY);
+SWIFT_THREAD_LOCAL_TYPE(Pointer<ExecutorTrackingInfo>,
+                        tls_key::concurrency_executor_tracking_info)
+ExecutorTrackingInfo::ActiveInfoInThread;
 
 } // end anonymous namespace
 
@@ -238,7 +216,7 @@ void swift::runJobInEstablishedExecutorContext(Job *job) {
     task->runInFullyEstablishedContext();
 
     assert(ActiveTask::get() == nullptr &&
-           "active task wasn't cleared before susspending?");
+           "active task wasn't cleared before suspending?");
   } else {
     // There's no extra bookkeeping to do for simple jobs besides swapping in
     // the voucher.
@@ -281,30 +259,20 @@ static ExecutorRef swift_task_getCurrentExecutorImpl() {
   return result;
 }
 
-#if defined(_WIN32)
-static HANDLE __initialPthread = INVALID_HANDLE_VALUE;
-#endif
-
 /// Determine whether we are currently executing on the main thread
 /// independently of whether we know that we are on the main actor.
 static bool isExecutingOnMainThread() {
-#if defined(__linux__)
-  return syscall(SYS_gettid) == getpid();
-#elif defined(_WIN32)
-  if (__initialPthread == INVALID_HANDLE_VALUE) {
-    DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
-                    GetCurrentProcess(), &__initialPthread, 0, FALSE,
-                    DUPLICATE_SAME_ACCESS);
-  }
-
-  return __initialPthread == GetCurrentThread();
+#if SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY
+  return true;
 #else
-  return pthread_main_np() == 1;
+  return Thread::onMainThread();
 #endif
 }
 
 JobPriority swift::swift_task_getCurrentThreadPriority() {
-#if defined(__APPLE__)
+#if SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY
+  return JobPriority::UserInitiated;
+#elif defined(__APPLE__)
   return static_cast<JobPriority>(qos_class_self());
 #else
   if (isExecutingOnMainThread())
@@ -344,8 +312,8 @@ void swift::swift_task_reportUnexpectedExecutor(
     const unsigned char *file, uintptr_t fileLength, bool fileIsASCII,
     uintptr_t line, ExecutorRef executor) {
   // Make sure we have an appropriate log level.
-  static swift_once_t logLevelToken;
-  swift_once(&logLevelToken, checkUnexpectedExecutorLogLevel, nullptr);
+  static swift::once_t logLevelToken;
+  swift::once(logLevelToken, checkUnexpectedExecutorLogLevel, nullptr);
 
   bool isFatalError = false;
   switch (unexpectedExecutorLogLevel) {

stdlib/public/BackDeployConcurrency/AsyncLet.cpp

@@ -17,8 +17,9 @@
 #include "CompatibilityOverride.h"
 #include "ConcurrencyRuntime.h"
 #include "swift/ABI/Metadata.h"
-#include "swift/Runtime/Mutex.h"
+#include "swift/Runtime/Heap.h"
 #include "swift/Runtime/HeapObject.h"
+#include "swift/Threading/Mutex.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "AsyncLet.h"
 #include "Debug.h"

stdlib/public/BackDeployConcurrency/AsyncStream.cpp

@@ -10,30 +10,24 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "swift/Runtime/Mutex.h"
+#include <new>
+
+#include "swift/Threading/Mutex.h"
 
 namespace swift {
 // return the size in words for the given mutex primitive
 extern "C"
 size_t _swift_async_stream_lock_size() {
-  size_t words = sizeof(MutexHandle) / sizeof(void *);
+  size_t words = sizeof(Mutex) / sizeof(void *);
   if (words < 1) { return 1; }
   return words;
 }
 
-extern "C"
-void _swift_async_stream_lock_init(MutexHandle &lock) {
-  MutexPlatformHelper::init(lock);
+extern "C" void _swift_async_stream_lock_init(Mutex &lock) {
+  new (&lock) Mutex();
 }
 
-extern "C"
-void _swift_async_stream_lock_lock(MutexHandle &lock) {
-  MutexPlatformHelper::lock(lock);
-}
-
-extern "C"
-void _swift_async_stream_lock_unlock(MutexHandle &lock) {
-  MutexPlatformHelper::unlock(lock);
-}
+extern "C" void _swift_async_stream_lock_lock(Mutex &lock) { lock.lock(); }
 
+extern "C" void _swift_async_stream_lock_unlock(Mutex &lock) { lock.unlock(); }
 }

stdlib/public/BackDeployConcurrency/CMakeLists.txt

@@ -99,6 +99,7 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   AsyncThrowingFlatMapSequence.swift
   AsyncThrowingMapSequence.swift
   AsyncThrowingPrefixWhileSequence.swift
+  ConditionVariable.cpp
   GlobalActor.swift
   MainActor.swift
   PartialAsyncTask.swift
@@ -114,7 +115,7 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   TaskLocal.swift
   TaskSleep.swift
   ThreadSanitizer.cpp
-  Mutex.cpp
+  ThreadingError.cpp
   AsyncStreamBuffer.swift
   AsyncStream.swift
   AsyncThrowingStream.swift
@@ -123,6 +124,8 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   ${swift_concurrency_extra_sources}
   ../Concurrency/linker-support/magic-symbols-for-install-name.c
 
+  INCORPORATE_OBJECT_LIBRARIES_SHARED_ONLY
+    swiftThreading
   LINK_LIBRARIES ${swift_concurrency_link_libraries}
 
   C_COMPILE_FLAGS

stdlib/public/BackDeployConcurrency/Mutex.cpp renamed to stdlib/public/BackDeployConcurrency/ConditionVariable.cpp

@@ -1,4 +1,4 @@
-//===--- Mutex.cpp - Mutex support code -----------------------------------===//
+//===--- ConditionVariable.cpp - A condition variable ---------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -11,21 +11,51 @@
 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
-
-#define SWIFT_FATAL_ERROR swift_Concurrency_fatalError
-
-// Include the runtime's mutex support code.
-// FIXME: figure out some reasonable way to share this stuff
-
 #include "ConditionVariable.h"
-#include "../runtime/MutexPThread.cpp"
-#include "../runtime/MutexWin32.cpp"
-#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
-  #include "swift/Runtime/MutexSingleThreaded.h"
-#endif
 
 using namespace swift;
 
+#define fatalError swift_Concurrency_fatalError
+
+#define reportError(PThreadFunction)                                           \
+  do {                                                                         \
+    int errorcode = PThreadFunction;                                           \
+    if (errorcode != 0) {                                                      \
+      fatalError(/* flags = */ 0, "'%s' failed with error '%s'(%d)\n",         \
+                 #PThreadFunction, errorName(errorcode), errorcode);           \
+    }                                                                          \
+  } while (false)
+
+#define returnTrueOrReportError(PThreadFunction, returnFalseOnEBUSY)           \
+  do {                                                                         \
+    int errorcode = PThreadFunction;                                           \
+    if (errorcode == 0)                                                        \
+      return true;                                                             \
+    if (returnFalseOnEBUSY && errorcode == EBUSY)                              \
+      return false;                                                            \
+    fatalError(/* flags = */ 0, "'%s' failed with error '%s'(%d)\n",           \
+               #PThreadFunction, errorName(errorcode), errorcode);             \
+  } while (false)
+
+static const char *errorName(int errorcode) {
+  switch (errorcode) {
+  case EINVAL:
+    return "EINVAL";
+  case EPERM:
+    return "EPERM";
+  case EDEADLK:
+    return "EDEADLK";
+  case ENOMEM:
+    return "ENOMEM";
+  case EAGAIN:
+    return "EAGAIN";
+  case EBUSY:
+    return "EBUSY";
+  default:
+    return "<unknown>";
+  }
+}
+
 void ConditionPlatformHelper::init(pthread_cond_t &condition) {
   reportError(pthread_cond_init(&condition, nullptr));
 }

stdlib/public/BackDeployConcurrency/ConditionVariable.h

@@ -18,7 +18,7 @@
 #ifndef SWIFT_RUNTIME_CONDITION_VARIABLE_H
 #define SWIFT_RUNTIME_CONDITION_VARIABLE_H
 
-#include "swift/Runtime/Mutex.h"
+#include "swift/Threading/Mutex.h"
 #include <type_traits>
 #include <utility>
 

stdlib/public/BackDeployConcurrency/DispatchGlobalExecutor.inc

@@ -118,7 +118,7 @@ extern "C" void dispatch_queue_set_width(dispatch_queue_t dq, long width);
 static dispatch_queue_t getGlobalQueue(JobPriority priority) {
   size_t numericPriority = static_cast<size_t>(priority);
   if (numericPriority >= globalQueueCacheCount)
-    swift_Concurrency_fatalError(0, "invalid job priority %#zx");
+    swift_Concurrency_fatalError(0, "invalid job priority %#zx", numericPriority);
 
 #ifdef SWIFT_CONCURRENCY_BACK_DEPLOYMENT
   std::memory_order loadOrder = std::memory_order_acquire;

stdlib/public/BackDeployConcurrency/Error.cpp

@@ -10,10 +10,27 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/Threading/Errors.h"
+#include <cstdio>
+
 #include "Error.h"
 
 // swift::fatalError is not exported from libswiftCore and not shared, so define another
 // internal function instead.
-SWIFT_NORETURN void swift::swift_Concurrency_fatalError(uint32_t flags, const char *format, ...) {
+SWIFT_NORETURN
+SWIFT_VFORMAT(2)
+void swift::swift_Concurrency_fatalErrorv(uint32_t flags, const char *format,
+                                          va_list val) {
+  vfprintf(stderr, format, val);
   abort();
 }
+
+SWIFT_NORETURN
+SWIFT_FORMAT(2, 3)
+void swift::swift_Concurrency_fatalError(uint32_t flags, const char *format,
+                                         ...) {
+  va_list val;
+
+  va_start(val, format);
+  swift_Concurrency_fatalErrorv(flags, format, val);
+}

stdlib/public/BackDeployConcurrency/Error.h

@@ -17,13 +17,19 @@
 #ifndef SWIFT_CONCURRENCY_ERRORS_H
 #define SWIFT_CONCURRENCY_ERRORS_H
 
+#include "swift/Basic/Compiler.h"
+
 #include "../SwiftShims/Visibility.h"
+#include <cstdarg>
 #include <cstdint>
-#include <stdlib.h>
+#include <cstdlib>
 
 namespace swift {
 
-SWIFT_NORETURN void swift_Concurrency_fatalError(uint32_t flags, const char *format, ...);
+SWIFT_NORETURN SWIFT_FORMAT(2, 3) void swift_Concurrency_fatalError(
+    uint32_t flags, const char *format, ...);
+SWIFT_NORETURN SWIFT_VFORMAT(2) void swift_Concurrency_fatalErrorv(
+    uint32_t flags, const char *format, va_list val);
 
 } // namespace swift
 

stdlib/public/BackDeployConcurrency/Executor.swift

@@ -93,7 +93,7 @@ func _checkExpectedExecutor(_filenameStart: Builtin.RawPointer,
     _filenameStart, _filenameLength, _filenameIsASCII, _line, _executor)
 }
 
-#if !SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+#if !SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY
 // This must take a DispatchQueueShim, not something like AnyObject,
 // or else SILGen will emit a retain/release in unoptimized builds,
 // which won't work because DispatchQueues aren't actually