Add Synchronization module

Author: Azoy

CMakeLists.txt

@@ -647,6 +647,10 @@ option(SWIFT_ENABLE_EXPERIMENTAL_OBSERVATION
   "Enable build of the Swift observation module"
   FALSE)
 
+option(SWIFT_ENABLE_SYNCHRONIZATION
+  "Enable build of the Swift Synchronization module"
+  FALSE)
+
 option(SWIFT_ENABLE_DISPATCH
   "Enable use of libdispatch"
   TRUE)
@@ -1222,6 +1226,7 @@ if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
   message(STATUS "Backtracing Support:                ${SWIFT_ENABLE_BACKTRACING}")
   message(STATUS "Unicode Support:                    ${SWIFT_STDLIB_ENABLE_UNICODE_DATA}")
   message(STATUS "Observation Support:                ${SWIFT_ENABLE_EXPERIMENTAL_OBSERVATION}")
+  message(STATUS "Synchronization Support:            ${SWIFT_ENABLE_SYNCHRONIZATION}")
   message(STATUS "")
 else()
   message(STATUS "Not building Swift standard library, SDK overlays, and runtime")

stdlib/cmake/modules/SwiftSource.cmake

@@ -321,6 +321,10 @@ function(_add_target_variant_swift_compile_flags
     list(APPEND result "-D" "SWIFT_ENABLE_EXPERIMENTAL_OBSERVATION")
   endif()
 
+  if (SWIFT_ENABLE_SYNCHRONIZATION)
+    list(APPEND result "-D" "SWIFT_ENABLE_SYNCHRONIZATION")
+  endif()
+
   if(SWIFT_STDLIB_OS_VERSIONING)
     list(APPEND result "-D" "SWIFT_RUNTIME_OS_VERSIONING")
   endif()

stdlib/public/CMakeLists.txt

@@ -245,6 +245,10 @@ if(SWIFT_BUILD_STDLIB AND NOT SWIFT_STDLIB_BUILD_ONLY_CORE_MODULES)
   if(SWIFT_ENABLE_BACKTRACING)
     add_subdirectory(Backtracing)
   endif()
+
+  if(SWIFT_ENABLE_SYNCHRONIZATION)
+    add_subdirectory(Synchronization)
+  endif()
 endif()
 
 if(SWIFT_BUILD_REMOTE_MIRROR)

utils/SwiftAtomics.py

@@ -0,0 +1,123 @@
+#===-----------------------------------------------------------------------===//
+#
+# This source file is part of the Swift.org open source project
+#
+# Copyright (c) 2023 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
+#
+#===-----------------------------------------------------------------------===//
+
+atomicTypes = [
+  # Swift                  Size    Alignment  Builtin
+  ("AtomicInt8Storage",     "8",         "1", "Builtin.Int8"),
+  ("AtomicInt16Storage",   "16",         "2", "Builtin.Int16"),
+  ("AtomicInt32Storage",   "32",         "4", "Builtin.Int32"),
+  ("AtomicInt64Storage",   "64",         "8", "Builtin.Int64"),
+  ("AtomicInt128Storage", "128",        "16", "Builtin.Int128"),
+]
+
+intTypes = [
+  # Swift   Storage Type 
+  ("Int8",  "AtomicInt8Storage",   "Int8"),
+  ("Int16", "AtomicInt16Storage",  "Int16"),
+  ("Int32", "AtomicInt32Storage",  "Int32"),
+  ("Int64", "AtomicInt64Storage",  "Int64"),
+
+  # We handle the word type's storage in source.
+  ("Int",   "",                    "Word"),
+
+  ("UInt8",  "AtomicInt8Storage",  "Int8"),
+  ("UInt16", "AtomicInt16Storage", "Int16"),
+  ("UInt32", "AtomicInt32Storage", "Int32"),
+  ("UInt64", "AtomicInt64Storage", "Int64"),
+
+  # We handle the word type's storage in source.
+  ("UInt",   "",                   "Word"),
+]
+
+loadOrderings = [
+  # Swift                    API name                  doc name                   LLVM name
+  ("relaxed",                "Relaxed",                "relaxed",                 "monotonic"),
+  ("acquiring",              "Acquiring",              "acquiring",               "acquire"),
+  ("sequentiallyConsistent", "SequentiallyConsistent", "sequentially consistent", "seqcst")
+]
+
+storeOrderings = [
+  # Swift enum case,         API name,                 doc name,                  LLVM name
+  ("relaxed",                "Relaxed",                "relaxed",                 "monotonic"),
+  ("releasing",              "Releasing",              "releasing",               "release"),
+  ("sequentiallyConsistent", "SequentiallyConsistent", "sequentially consistent", "seqcst")
+]
+
+updateOrderings = [
+  # Swift enum case,         API name,                 doc name,                  LLVM name,   failure name
+  ("relaxed",                "Relaxed",                "relaxed",                 "monotonic", "monotonic"),
+  ("acquiring",              "Acquiring",              "acquiring",               "acquire",   "acquire"),
+  ("releasing",              "Releasing",              "releasing",               "release",   "monotonic"),
+  ("acquiringAndReleasing",  "AcquiringAndReleasing",  "acquiring-and-releasing", "acqrel",    "acquire"),
+  ("sequentiallyConsistent", "SequentiallyConsistent", "sequentially consistent", "seqcst",    "seqcst"),
+]
+
+integerOperations = [
+  # Swift name,         llvm name,  operator, label,  doc name
+  ("WrappingIncrement", "add",      "&+",     "by",   "wrapping add"),
+  ("WrappingDecrement", "sub",      "&-",     "by",   "wrapping subtract"),
+  ("BitwiseAnd",        "and",      "&",      "with", "bitwise AND"),
+  ("BitwiseOr",         "or",       "|",      "with", "bitwise OR"),
+  ("BitwiseXor",        "xor",      "^",      "with", "bitwise XOR"),
+
+  # These two are handled specially in source.
+  ("Min",               "min",      "",       "with", "minimum"),
+  ("Max",               "max",      "",       "with", "maximum")
+]
+
+boolOperations = [
+  # Swift name,  llvm name, operator, label,  doc
+  ("LogicalAnd", "and",     "&&",     "with", "logical AND"),
+  ("LogicalOr",  "or",      "||",     "with", "logical OR"),
+  ("LogicalXor", "xor",     "!=",     "with", "logical XOR")
+]
+
+# LLVM doesn't support arbitrary ordering combinations yet, so for the
+# two-ordering cmpxchg variants we need to upgrade the success
+# ordering when necessary so that it is at least as "strong" as the
+# failure case. This function implements that mapping.
+#
+# See llvm/Support/AtomicOrdering.h
+def actualOrders(success, failure):
+  def max(success, failure):
+    if failure == "acquire":
+      if success == "monotonic":
+       return "acquire"
+      if success == "release":
+       return "acqrel"
+    if failure == "seqcst":
+      return "seqcst"
+    return success
+  actualSuccess = max(success, failure)
+  return actualSuccess + "_" + failure
+
+def llvmToCaseName(ordering):
+  if ordering == "monotonic":
+    return "relaxed"
+  if ordering == "acquire":
+    return "acquiring"
+  if ordering == "release":
+    return "releasing"
+  if ordering == "acqrel":
+    return "acquiringAndReleasing"
+  if ordering == "seqcst":
+    return "sequentiallyConsistent"
+
+def atomicOperationName(intType, operation):
+  if operation == "Min":
+    return "umin" if intType.startswith("U") else "min"
+  if operation == "Max":
+    return "umax" if intType.startswith("U") else "max"
+  return operation
+
+def lowerFirst(str):
+  return str[:1].lower() + str[1:] if str else ""

utils/build_swift/build_swift/driver_arguments.py

@@ -1342,6 +1342,10 @@ def create_argument_parser():
            default=True,
            help='Enable experimental Swift observation.')
 
+    option('--enable-synchronization', toggle_true,
+           default=True,
+           help='Enable Swift Synchronization')
+
     # -------------------------------------------------------------------------
     in_group('Unsupported options')
 

utils/swift-api-dump.py

@@ -106,6 +106,8 @@ def create_parser():
                         help='Enable experimental distributed actors.')
     parser.add_argument('--enable-experimental-observation', action='store_true',
                         help='Enable experimental observation.')
+    parser.add_argument('--enable-synchronization', action='store_true',
+                        help='Enable Synchronization.')
     parser.add_argument('-swift-version', metavar='N',
                         help='the Swift version to use')
     parser.add_argument('-show-overlay', action='store_true',

utils/swift_build_support/swift_build_support/products/swift.py

@@ -65,6 +65,9 @@ def __init__(self, args, toolchain, source_dir, build_dir):
         # Add experimental observation flag.
         self.cmake_options.extend(self._enable_experimental_observation)
 
+        # Add synchronization flag.
+        self.cmake_options.extend(self._enable_synchronization)
+
         # Add static vprintf flag
         self.cmake_options.extend(self._enable_stdlib_static_vprintf)
 
@@ -197,6 +200,11 @@ def _enable_experimental_observation(self):
         return [('SWIFT_ENABLE_EXPERIMENTAL_OBSERVATION:BOOL',
                  self.args.enable_experimental_observation)]
 
+    @property
+    def _enable_synchronization(self):
+        return [('SWIFT_ENABLE_SYNCHRONIZATION:BOOL',
+                 self.args.enable_synchronization)]
+
     @property
     def _enable_stdlib_static_vprintf(self):
         return [('SWIFT_STDLIB_STATIC_PRINT',