stdlib: implement _stdlib_create_pthread_block in terms of Windows threaing

Port the block based thread constructor to Windows threading model, and
rename it to `_stdlib_create_thread_block`.

Author: compnerd

stdlib/private/StdlibUnittest/RaceTest.swift

@@ -605,21 +605,21 @@ public func runRaceTest<RT : RaceTestWithPerTrialData>(
 
   // Create the master thread.
   do {
-    let (ret, tid) = _stdlib_pthread_create_block(masterThreadBody, ())
+    let (ret, tid) = _stdlib_thread_create_block(masterThreadBody, ())
     expectEqual(0, ret)
     testTids.append(tid!)
   }
 
   // Create racing threads.
   for i in 0..<racingThreadCount {
-    let (ret, tid) = _stdlib_pthread_create_block(racingThreadBody, i)
+    let (ret, tid) = _stdlib_thread_create_block(racingThreadBody, i)
     expectEqual(0, ret)
     testTids.append(tid!)
   }
 
   // Create the alarm thread that enforces the timeout.
   do {
-    let (ret, tid) = _stdlib_pthread_create_block(alarmThreadBody, ())
+    let (ret, tid) = _stdlib_thread_create_block(alarmThreadBody, ())
     expectEqual(0, ret)
     alarmTid = tid!
   }

stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift

@@ -19,6 +19,8 @@
 import Darwin
 #elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android) || os(Cygwin) || os(Haiku)
 import Glibc
+#elseif os(Windows)
+import MSVCRT
 #endif
 
 /// An abstract base class to encapsulate the context necessary to invoke
@@ -59,16 +61,43 @@ internal func invokeBlockContext(
   return context.run()
 }
 
+#if os(Windows)
+public typealias ThreadHandle = HANDLE
+#else
+public typealias ThreadHandle = pthread_t
+
+#if os(Linux) || os(Android)
+internal func _make_pthread_t() -> pthread_t {
+  return pthread_t()
+}
+#else
+internal func _make_pthread_t() -> pthread_t? {
+  return nil
+}
+#endif
+#endif
+
 /// Block-based wrapper for `pthread_create`.
-public func _stdlib_pthread_create_block<Argument, Result>(
+public func _stdlib_thread_create_block<Argument, Result>(
   _ start_routine: @escaping (Argument) -> Result,
   _ arg: Argument
-) -> (CInt, pthread_t?) {
+) -> (CInt, ThreadHandle?) {
   let context = ThreadBlockContextImpl(block: start_routine, arg: arg)
   // We hand ownership off to `invokeBlockContext` through its void context
   // argument.
   let contextAsVoidPointer = Unmanaged.passRetained(context).toOpaque()
 
+#if os(Windows)
+  var threadID =
+      _beginthreadex(nil, 0, { invokeBlockContext($0)!
+                                  .assumingMemoryBound(to: UInt32.self).pointee },
+                     contextAsVoidPointer, 0, nil)
+  if threadID == 0 {
+    return (errno, nil)
+  } else {
+    return (0, UnsafeMutablePointer<ThreadHandle>(&threadID).pointee)
+  }
+#else
   var threadID = _make_pthread_t()
   let result = pthread_create(&threadID, nil,
     { invokeBlockContext($0) }, contextAsVoidPointer)
@@ -77,17 +106,8 @@ public func _stdlib_pthread_create_block<Argument, Result>(
   } else {
     return (result, nil)
   }
-}
-
-#if os(Linux) || os(Android)
-internal func _make_pthread_t() -> pthread_t {
-  return pthread_t()
-}
-#else
-internal func _make_pthread_t() -> pthread_t? {
-  return nil
-}
 #endif
+}
 
 /// Block-based wrapper for `pthread_join`.
 public func _stdlib_pthread_join<Result>(

test/Interpreter/enforce_exclusive_access.swift

@@ -120,7 +120,7 @@ ExclusiveAccessTestSuite.test("ClosureCaptureReadRead") {
 // have overlapping accesses
 ExclusiveAccessTestSuite.test("PerThreadEnforcement") {
   modifyAndPerform(&globalX) {
-    let (_, otherThread) = _stdlib_pthread_create_block({ (_ : Void) -> () in
+    let (_, otherThread) = _stdlib_thread_create_block({ (_ : Void) -> () in
       globalX.i = 12 // no-trap
       return ()
     }, ())

validation-test/stdlib/StringSlicesConcurrentAppend.swift

@@ -93,9 +93,9 @@ StringTestSuite.test("SliceConcurrentAppend") {
   var ret = _stdlib_thread_barrier_init(barrierVar!, 2)
   expectEqual(0, ret)
 
-  let (createRet1, tid1) = _stdlib_pthread_create_block(
+  let (createRet1, tid1) = _stdlib_thread_create_block(
     sliceConcurrentAppendThread, .Primary)
-  let (createRet2, tid2) = _stdlib_pthread_create_block(
+  let (createRet2, tid2) = _stdlib_thread_create_block(
     sliceConcurrentAppendThread, .Secondary)
 
   expectEqual(0, createRet1)