Add a single-threaded stdlib mode, use it for the 'minimal' stdlib

Author: kubamracek

CMakeLists.txt

@@ -390,10 +390,6 @@ option(SWIFT_RUNTIME_ENABLE_LEAK_CHECKER
   "Should the runtime be built with support for non-thread-safe leak detecting entrypoints"
   FALSE)
 
-option(SWIFT_STDLIB_USE_NONATOMIC_RC
-    "Build the standard libraries and overlays with nonatomic reference count operations enabled"
-    FALSE)
-
 option(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS
   "Enable runtime function counters and expose the API."
   FALSE)

include/swift/Basic/Lazy.h

@@ -14,7 +14,9 @@
 #define SWIFT_BASIC_LAZY_H
 
 #include <memory>
-#ifdef __APPLE__
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+// No dependencies on single-threaded environments.
+#elif defined(__APPLE__)
 #include <dispatch/dispatch.h>
 #elif defined(__wasi__)
 // No pthread on wasi, see https://bugs.swift.org/browse/SR-12097 for more details.
@@ -44,7 +46,11 @@ inline void wasi_call_once(int *flag, void *context, void (*func)(void *)) {
 
 namespace swift {
 
-#ifdef __APPLE__
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  using OnceToken_t = bool;
+# define SWIFT_ONCE_F(TOKEN, FUNC, CONTEXT) \
+  if (!TOKEN) { TOKEN = true; (FUNC)(CONTEXT); }
+#elif defined(__APPLE__)
   using OnceToken_t = dispatch_once_t;
 # define SWIFT_ONCE_F(TOKEN, FUNC, CONTEXT) \
   ::dispatch_once_f(&TOKEN, CONTEXT, FUNC)

include/swift/Runtime/Mutex.h

@@ -20,12 +20,14 @@
 
 #include <type_traits>
 
-#if (defined(__APPLE__) || defined(__linux__) || defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__HAIKU__))
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+#include "swift/Runtime/MutexSingleThreaded.h"
+#elif (defined(__APPLE__) || defined(__linux__) || defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__HAIKU__))
 #include "swift/Runtime/MutexPThread.h"
 #elif defined(_WIN32)
 #include "swift/Runtime/MutexWin32.h"
 #elif defined(__wasi__)
-#include "swift/Runtime/MutexWASI.h"
+#include "swift/Runtime/MutexSingleThreaded.h"
 #else
 #error "Implement equivalent of MutexPThread.h/cpp for your platform."
 #endif

include/swift/Runtime/MutexWASI.h renamed to include/swift/Runtime/MutexSingleThreaded.h

@@ -1,4 +1,4 @@
-//===--- MutexWASI.h - -----------------------------------------*- C++ -*-===//
+//===--- MutexSingleThreaded.h - --------------------------------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,16 +10,12 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// No-op implementation of locks for the WebAssembly System Interface. The 
-// implementation does not need to perform locking, because as of January 2020 
-// WebAssembly does not support threads.
-// See the current status at https://github.com/WebAssembly/proposals and 
-// https://github.com/webassembly/threads
+// No-op implementation of locks for single-threaded environments.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_RUNTIME_MUTEX_WASI_H
-#define SWIFT_RUNTIME_MUTEX_WASI_H
+#ifndef SWIFT_RUNTIME_MUTEX_SINGLE_THREADED_H
+#define SWIFT_RUNTIME_MUTEX_SINGLE_THREADED_H
 
 namespace swift {
 

include/swift/Runtime/Once.h

@@ -22,7 +22,11 @@
 
 namespace swift {
 
-#ifdef __APPLE__
+#ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+
+typedef bool swift_once_t;
+
+#elif defined(__APPLE__)
 
 // On OS X and iOS, swift_once_t matches dispatch_once_t.
 typedef long swift_once_t;

stdlib/CMakeLists.txt

@@ -21,6 +21,18 @@ option(SWIFT_RUNTIME_MACHO_NO_DYLD
   "Build stdlib assuming the runtime environment uses Mach-O but does not support dynamic modules."
   FALSE)
 
+option(SWIFT_STDLIB_USE_NONATOMIC_RC
+    "Build the standard libraries and overlays with nonatomic reference count operations enabled"
+    FALSE)
+
+option(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+    "Build the standard libraries assuming that they will be used in an environment with only a single thread. If set, also forces SWIFT_STDLIB_USE_NONATOMIC_RC to On."
+    FALSE)
+
+if(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME)
+  set(SWIFT_STDLIB_USE_NONATOMIC_RC TRUE)
+endif()
+
 #
 # End of user-configurable options.
 #

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -306,6 +306,14 @@ function(_add_target_variant_c_compile_flags)
     list(APPEND result "-DSWIFT_RUNTIME_MACHO_NO_DYLD")
   endif()
 
+  if(SWIFT_STDLIB_USE_NONATOMIC_RC)
+    list(APPEND result "-DSWIFT_STDLIB_USE_NONATOMIC_RC")
+  endif()
+
+  if(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME)
+    list(APPEND result "-DSWIFT_STDLIB_SINGLE_THREADED_RUNTIME")
+  endif()
+
   set("${CFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
 endfunction()
 

stdlib/public/runtime/CMakeLists.txt

@@ -152,16 +152,12 @@ if(SWIFT_BUILD_STATIC_STDLIB AND "${sdk}" STREQUAL "LINUX")
     INSTALL_IN_COMPONENT never_install)
 endif()
 
-if(SWIFT_STDLIB_USE_NONATOMIC_RC)
-  set(_RUNTIME_NONATOMIC_FLAGS -DSWIFT_STDLIB_USE_NONATOMIC_RC)
-endif()
 add_swift_target_library(swiftRuntime OBJECT_LIBRARY
   ${swift_runtime_sources}
   ${swift_runtime_objc_sources}
   ${swift_runtime_leaks_sources}
   C_COMPILE_FLAGS
     ${swift_runtime_library_compile_flags}
-    ${_RUNTIME_NONATOMIC_FLAGS}
   LINK_FLAGS ${swift_runtime_linker_flags}
   SWIFT_COMPILE_FLAGS ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}
   INSTALL_IN_COMPONENT never_install)

stdlib/public/runtime/Exclusivity.cpp

@@ -250,7 +250,14 @@ class SwiftTLSContext {
 // Each of these cases should define a function with this prototype:
 //   AccessSets &getAllSets();
 
-#if SWIFT_TLS_HAS_RESERVED_PTHREAD_SPECIFIC
+#if SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+
+static SwiftTLSContext &getTLSContext() {
+  static SwiftTLSContext TLSContext;
+  return TLSContext;
+}
+
+#elif SWIFT_TLS_HAS_RESERVED_PTHREAD_SPECIFIC
 // Use the reserved TSD key if possible.
 
 static SwiftTLSContext &getTLSContext() {

stdlib/public/runtime/MetadataCache.h

@@ -775,10 +775,22 @@ class MetadataCacheEntryBase
   using super::asImpl;
 
 private:
+  #ifdef SWIFT_STDLIB_SINGLE_THREADED_RUNTIME
+  using ThreadID = int;
+  static ThreadID CurrentThreadID() {
+    return 0;
+  }
+  #else
+  using ThreadID = std::thread::id;
+  static ThreadID CurrentThreadID() {
+    return std::this_thread::get_id();
+  }
+  #endif
+
   /// Additional storage that is only ever accessed under the lock.
   union LockedStorage_t {
     /// The thread that is allocating the entry.
-    std::thread::id AllocatingThread;
+    ThreadID AllocatingThread;
 
     /// The completion queue.
     MetadataCompletionQueueEntry *CompletionQueue;
@@ -837,7 +849,7 @@ class MetadataCacheEntryBase
   MetadataCacheEntryBase()
       : LockedStorageKind(LSK::AllocatingThread),
         TrackingInfo(PrivateMetadataTrackingInfo::initial().getRawValue()) {
-    LockedStorage.AllocatingThread = std::this_thread::get_id();
+    LockedStorage.AllocatingThread = CurrentThreadID();
   }
 
   // Note that having an explicit destructor here is important to make this
@@ -850,7 +862,7 @@ class MetadataCacheEntryBase
 
   bool isBeingAllocatedByCurrentThread() const {
     return LockedStorageKind == LSK::AllocatingThread &&
-           LockedStorage.AllocatingThread == std::this_thread::get_id();
+           LockedStorage.AllocatingThread == CurrentThreadID();
   }
 
   /// Given that this thread doesn't own the right to initialize the