[Concurrency][Threading] Remove use of platform thread functions.

The concurrency library can use the new threading library functions,
which avoids the problem of including <windows.h>.

rdar://90776105

Author: al45tair

include/swift/Threading/Thread.h

@@ -25,11 +25,15 @@ namespace swift {
 
 /// Identifies a thread
 class Thread {
+public:
+  using Id = threading_impl::thread_id;
+
 private:
-  threading_impl::thread_id id_;
+  Id id_;
 
 public:
   Thread() {}
+  explicit Thread(Id platformId) : id_(platformId) {}
   Thread(const Thread& other) : id_(other.id_) {}
   Thread(Thread&& other) : id_(std::move(other.id_)) {}
 
@@ -43,6 +47,9 @@ class Thread {
     return *this;
   }
 
+  /// Returns the platform specific thread ID
+  Id platformThreadId() const { return id_; }
+
   /// Returns the currently executing thread
   static Thread current() {
     return Thread(threading_impl::thread_get_current());

lib/Threading/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_swift_host_library(swiftThreading STATIC
   C11.cpp
+  Darwin.cpp
   Linux.cpp
   Nothreads.cpp
   Pthreads.cpp

lib/Threading/Darwin.cpp

@@ -0,0 +1,57 @@
+//==--- Darwin.cpp - Threading abstraction implementation ------ -*-C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Implements threading support for Darwin
+//
+//===----------------------------------------------------------------------===//
+
+#if SWIFT_THREADING_DARWIN
+
+#include <pthread.h>
+
+#include "swift/Threading/Errors.h"
+#include "swift/Threading/Impl/Darwin.h"
+
+namespace {
+
+#pragma clang diagnostic push
+#pragma GCC diagnostic ignored "-Wglobal-constructors"
+
+class MainThreadRememberer {
+private:
+  pthread_t mainThread_;
+public:
+  MainThreadRememberer() { mainThread_ = pthread_self(); }
+
+  pthread_t main_thread() const { return mainThread_; }
+};
+
+MainThreadRememberer rememberer;
+
+#pragma clang diagnostic pop
+
+}
+
+using namespace swift;
+using namespace threading_impl;
+
+thread_id
+swift::threading_impl::thread_get_main() {
+  return rememberer.main_thread();
+}
+
+bool
+swift::threading_impl::thread_is_main() {
+  return pthread_main_np();
+}
+
+#endif // SWIFT_THREADING_DARWIN

stdlib/public/Concurrency/Actor.cpp

@@ -35,6 +35,7 @@
 #include "swift/Threading/Once.h"
 #include "swift/Threading/Mutex.h"
 #include "swift/Threading/ThreadLocalStorage.h"
+#include "swift/Threading/Thread.h"
 #include "swift/ABI/Task.h"
 #include "swift/ABI/Actor.h"
 #include "swift/Basic/ListMerger.h"
@@ -67,21 +68,6 @@
 #include <sys/syscall.h>
 #endif
 
-#if defined(_POSIX_THREADS)
-#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
 extern "C" void *objc_autoreleasePoolPush();
 extern "C" void objc_autoreleasePoolPop(void *);
@@ -278,29 +264,13 @@ 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 SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY
   return true;
-#elif 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();
-#elif defined(__wasi__)
-  return true;
 #else
-  return pthread_main_np() == 1;
+  return Thread::onMainThread();
 #endif
 }
 

stdlib/public/Concurrency/TaskPrivate.h

@@ -17,13 +17,6 @@
 #ifndef SWIFT_CONCURRENCY_TASKPRIVATE_H
 #define SWIFT_CONCURRENCY_TASKPRIVATE_H
 
-#if defined(_WIN32)
-#define WIN32_LEAN_AND_MEAN
-#define VC_EXTRA_LEAN
-#define NOMINMAX
-#include <Windows.h>
-#endif
-
 #include "Error.h"
 #include "Tracing.h"
 #include "swift/ABI/Metadata.h"
@@ -34,41 +27,23 @@
 #include "swift/Runtime/Error.h"
 #include "swift/Runtime/Exclusivity.h"
 #include "swift/Runtime/HeapObject.h"
+#include "swift/Threading/Thread.h"
 #include <atomic>
 #include <new>
 
 #define SWIFT_FATAL_ERROR swift_Concurrency_fatalError
 #include "../runtime/StackAllocator.h"
 
-#if HAVE_PTHREAD_H
-#include <pthread.h>
-#endif
-
 namespace swift {
 
 // Set to 1 to enable helpful debug spew to stderr
 // If this is enabled, tests with `swift_task_debug_log` requirement can run.
 #if 0
 #define SWIFT_TASK_DEBUG_LOG(fmt, ...)                                         \
   fprintf(stderr, "[%lu] [%s:%d](%s) " fmt "\n",                               \
-          (unsigned long)_swift_get_thread_id(),                               \
+          (unsigned long)Thread::current()::platformThreadId(),                \
           __FILE__, __LINE__, __FUNCTION__,                                    \
           __VA_ARGS__)
-
-#if defined(_WIN32)
-using ThreadID = decltype(GetCurrentThreadId());
-#else
-using ThreadID = decltype(pthread_self());
-#endif
-
-inline ThreadID _swift_get_thread_id() {
-#if defined(_WIN32)
-  return GetCurrentThreadId();
-#else
-  return pthread_self();
-#endif
-}
-
 #else
 #define SWIFT_TASK_DEBUG_LOG(fmt, ...) (void)0
 #endif

stdlib/public/Threading/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_swift_target_library(swiftThreading OBJECT_LIBRARY
   "${SWIFT_SOURCE_DIR}/lib/Threading/C11.cpp"
+  "${SWIFT_SOURCE_DIR}/lib/Threading/Darwin.cpp"
   "${SWIFT_SOURCE_DIR}/lib/Threading/Linux.cpp"
   "${SWIFT_SOURCE_DIR}/lib/Threading/Nothreads.cpp"
   "${SWIFT_SOURCE_DIR}/lib/Threading/Pthreads.cpp"