[DO NOT MERGE] Atomic experiments

stdlib/private/SwiftPrivate/AtomicInt.swift

@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 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
+//
+//===----------------------------------------------------------------------===//
+
+import Swift
+@_implementationOnly import Atomics
+
+// This type intentionally shadows the stdlib one
+@available(swift, introduced: 5.0)
+public final class _stdlib_AtomicInt {
+  internal var _valueStorage: Int
+
+  // FIXME: This should be an UnsafeAtomicInt, but we don't want to constrain
+  // availability.
+  internal var _valuePtr: UnsafeMutableRawPointer {
+    return _getUnsafePointerToStoredProperties(self)
+  }
+
+  public init(_ value: Int = 0) {
+    _valueStorage = value
+  }
+
+  public func store(_ desired: Int) {
+    _valuePtr._atomicReleasingStoreWord(UInt(bitPattern: desired))
+  }
+
+  public func load() -> Int {
+    return Int(bitPattern: _valuePtr._atomicAcquiringLoadWord())
+  }
+
+  @discardableResult
+  public func fetchAndAdd(_ operand: Int) -> Int {
+    let word = _valuePtr._atomicSerializedLoadThenWrappingIncrementWord(
+      by: UInt(bitPattern: operand))
+    return Int(bitPattern: word)
+  }
+  @discardableResult
+  public func fetchAndAnd(_ operand: Int) -> Int {
+    let word = _valuePtr._atomicSerializedLoadThenBitwiseAndWord(
+      UInt(bitPattern: operand))
+    return Int(bitPattern: word)
+  }
+  @discardableResult
+  public func fetchAndOr(_ operand: Int) -> Int {
+    let word = _valuePtr._atomicSerializedLoadThenBitwiseOrWord(
+      UInt(bitPattern: operand))
+    return Int(bitPattern: word)
+  }
+  @discardableResult
+  public func fetchAndXor(_ operand: Int) -> Int {
+    let word = _valuePtr._atomicSerializedLoadThenBitwiseXorWord(
+      UInt(bitPattern: operand))
+    return Int(bitPattern: word)
+  }
+
+  public func addAndFetch(_ operand: Int) -> Int {
+    return fetchAndAdd(operand) + operand
+  }
+  public func andAndFetch(_ operand: Int) -> Int {
+    return fetchAndAnd(operand) & operand
+  }
+  public func orAndFetch(_ operand: Int) -> Int {
+    return fetchAndOr(operand) | operand
+  }
+  public func xorAndFetch(_ operand: Int) -> Int {
+    return fetchAndXor(operand) ^ operand
+  }
+
+  public func compareExchange(expected: inout Int, desired: Int) -> Bool {
+    let expectedWord = UInt(bitPattern: expected)
+    let (success, originalWord) = _valuePtr._atomicSerializedCompareExchangeWord(
+      expected: expectedWord,
+      desired: UInt(bitPattern: desired))
+    expected = Int(bitPattern: originalWord)
+    return success
+  }
+}
+

stdlib/private/SwiftPrivate/CMakeLists.txt

@@ -9,12 +9,11 @@ add_swift_target_library(swiftSwiftPrivate ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
 
   IO.swift
   ShardedAtomicCounter.swift
+  AtomicInt.swift
 
   "${SWIFT_SOURCE_DIR}/stdlib/linker-support/magic-symbols-for-install-name.c"
 
-  GYB_SOURCES
-    AtomicInt.swift.gyb
-
+  SWIFT_MODULE_DEPENDS Atomics
   SWIFT_MODULE_DEPENDS_WINDOWS MSVCRT WinSDK
   SWIFT_COMPILE_FLAGS ${swift_swiftprivate_compile_flags} ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}
   INSTALL_IN_COMPONENT stdlib-experimental

stdlib/private/SwiftPrivate/ShardedAtomicCounter.swift

@@ -12,6 +12,7 @@
 
 import Swift
 import SwiftShims
+@_implementationOnly import Atomics
 
 public func _stdlib_getHardwareConcurrency() -> Int {
   // This is effectively a re-export of this shims function
@@ -49,8 +50,11 @@ public struct _stdlib_ShardedAtomicCounter {
 
   public func add(_ operand: Int, randomInt: Int) {
     let shardIndex = Int(UInt(bitPattern: randomInt) % UInt(self._shardsCount))
-    _ = _swift_stdlib_atomicFetchAddInt(
-      object: self._shardsPtr + shardIndex, operand: operand)
+    // FIXME: We should use UnsafeAtomicInt here, but we don't want to constrain
+    // availability.
+    let raw = UnsafeMutableRawPointer(self._shardsPtr + shardIndex)
+    _ = raw._atomicRelaxedLoadThenWrappingIncrementWord(
+      by: UInt(bitPattern: operand))
   }
 
   // FIXME: non-atomic as a whole!
@@ -59,7 +63,10 @@ public struct _stdlib_ShardedAtomicCounter {
     let shards = self._shardsPtr
     let count = self._shardsCount
     for i in 0..<count {
-      result += _swift_stdlib_atomicLoadInt(object: shards + i)
+      // FIXME: We should use UnsafeAtomicInt here, but we don't want to constrain
+      // availability.
+      let raw = UnsafeMutableRawPointer(shards + i)
+      result += Int(bitPattern: raw._atomicRelaxedLoadWord())
     }
     return result
   }