ManagedAtomic, ManagedAtomicLazyReference: Only forward to noncopyable atomics when they exist

lorentey · lorentey · commit 24506678e022 · 2023-08-18T17:05:22.000-07:00
diff --git a/Sources/Atomics/AtomicBool.swift.gyb b/Sources/Atomics/AtomicBool.swift.gyb
@@ -266,9 +266,16 @@ extension ManagedAtomic where Value == Bool {
     ${label} operand: Value,
     ordering: AtomicUpdateOrdering
   ) -> Value {
+#if compiler(>=5.9) && $RawLayout
     _storage.loadThen${name}(
       ${argLabel(label)}operand,
       ordering: ordering)
+#else
+    Value.AtomicRepresentation.atomicLoadThen${name}(
+      ${argLabel(label)}operand,
+      at: _ptr,
+      ordering: ordering)
+#endif
   }
 % end
 }
@@ -287,9 +294,17 @@ extension ManagedAtomic where Value == Bool {
     ${label} operand: Value,
     ordering: AtomicUpdateOrdering
   ) -> Value {
+#if compiler(>=5.9) && $RawLayout
     _storage.${lowerFirst(name)}ThenLoad(
       ${argLabel(label)}operand,
       ordering: ordering)
+#else
+    let original = Value.AtomicRepresentation.atomicLoadThen${name}(
+      ${argLabel(label)}operand,
+      at: _ptr,
+      ordering: ordering)
+    return original ${op} operand
+#endif
   }
 % end
 }
diff --git a/Sources/Atomics/AtomicLazyReference.swift b/Sources/Atomics/AtomicLazyReference.swift
@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if compiler(>=5.9) && $RawLayout
 /// A lazily initializable atomic strong reference.
 ///
 /// These values can be set (initialized) exactly once, but read many
@@ -85,6 +86,7 @@ extension AtomicLazyReference {
     return value?.takeUnretainedValue()
   }
 }
+#endif
 
 /// An unsafe reference type holding a lazily initializable atomic
 /// strong reference, requiring manual memory management of the
@@ -255,6 +257,7 @@ public class ManagedAtomicLazyReference<Instance: AnyObject> {
   /// The value logically stored in an atomic lazy reference value.
   public typealias Value = Instance?
 
+#if compiler(>=5.9) && $RawLayout
   /// The actual lazily initialized reference value.
   @usableFromInline
   internal let _storage: AtomicLazyReference<Instance>
@@ -265,10 +268,38 @@ public class ManagedAtomicLazyReference<Instance: AnyObject> {
     _storage = AtomicLazyReference()
   }
 
+  deinit {}
+#else
+  @usableFromInline
+  internal typealias _Rep = Optional<Unmanaged<Instance>>.AtomicRepresentation
+
+  /// The atomic representation of the value stored inside.
+  ///
+  /// Warning: This ivar must only ever be accessed via `_ptr` after
+  /// its initialization.
+  @usableFromInline
+  internal let _storage: _Rep
+
+  /// Initializes a new managed atomic lazy reference with a nil value.
+  @inlinable
+  public init() {
+    _storage = _Rep(nil)
+  }
+
   deinit {
+    if let unmanaged = _ptr.pointee.dispose() {
+      unmanaged.release()
+    }
+  }
+
+  @_alwaysEmitIntoClient @inline(__always)
+  internal var _ptr: UnsafeMutablePointer<_Rep> {
+    _getUnsafePointerToStoredProperties(self).assumingMemoryBound(to: _Rep.self)
   }
+#endif
 }
 
+
 extension ManagedAtomicLazyReference: @unchecked Sendable
 where Instance: Sendable {}
 
@@ -298,14 +329,36 @@ extension ManagedAtomicLazyReference {
   ///
   /// This operation uses acquiring-and-releasing memory ordering.
   public func storeIfNilThenLoad(_ desired: __owned Instance) -> Instance {
+#if compiler(>=5.9) && $RawLayout
     _storage.storeIfNilThenLoad(desired)
+#else
+    let desiredUnmanaged = Unmanaged.passRetained(desired)
+    let (exchanged, current) = _Rep.atomicCompareExchange(
+      expected: nil,
+      desired: desiredUnmanaged,
+      at: _ptr,
+      ordering: .acquiringAndReleasing)
+    if !exchanged {
+      // The reference has already been initialized. Balance the retain that
+      // we performed on `desired`.
+      desiredUnmanaged.release()
+      return current!.takeUnretainedValue()
+    }
+    return desiredUnmanaged.takeUnretainedValue()
+#endif
   }
 
   /// Atomically loads and returns the current value of this reference.
   ///
   /// The load operation is performed with the memory ordering
   /// `AtomicLoadOrdering.acquiring`.
   public func load() -> Instance? {
+#if compiler(>=5.9) && $RawLayout
     _storage.load()
+#else
+    let value = _Rep.atomicLoad(at: _ptr, ordering: .acquiring)
+    return value?.takeUnretainedValue()
+#endif
   }
 }
+
diff --git a/Sources/Atomics/IntegerOperations.swift.gyb b/Sources/Atomics/IntegerOperations.swift.gyb
@@ -223,9 +223,16 @@ extension ManagedAtomic where Value: AtomicInteger {
     ${label} operand: Value${" = 1" if "crement" in name else ""},
     ordering: AtomicUpdateOrdering
   ) -> Value {
+#if compiler(>=5.9) && $RawLayout
     _storage.loadThen${name}(
       ${argLabel(label)}operand,
       ordering: ordering)
+#else
+    _Storage.atomicLoadThen${name}(
+      ${argLabel(label)}operand,
+      at: _ptr,
+      ordering: ordering)
+#endif
   }
 
   % end
@@ -248,9 +255,17 @@ extension ManagedAtomic where Value: AtomicInteger {
     ${label} operand: Value${" = 1" if "crement" in name else ""},
     ordering: AtomicUpdateOrdering
   ) -> Value {
+#if compiler(>=5.9) && $RawLayout
     _storage.${lowerFirst(name)}ThenLoad(
       ${argLabel(label)}operand,
       ordering: ordering)
+#else
+    let original = _Storage.atomicLoadThen${name}(
+      ${argLabel(label)}operand,
+      at: _ptr,
+      ordering: ordering)
+    return original ${op} operand
+#endif
   }
 
   % end
@@ -269,9 +284,16 @@ extension ManagedAtomic where Value: AtomicInteger {
     by operand: Value = 1,
     ordering: AtomicUpdateOrdering
   ) {
+#if compiler(>=5.9) && $RawLayout
     _ = _storage.loadThenWrappingIncrement(
       by: operand,
       ordering: ordering)
+#else
+    _ = _Storage.atomicLoadThenWrappingIncrement(
+      by: operand,
+      at: _ptr,
+      ordering: ordering)
+#endif
   }
 
   /// Perform an atomic wrapping decrement operation applying the
@@ -288,8 +310,15 @@ extension ManagedAtomic where Value: AtomicInteger {
     by operand: Value = 1,
     ordering: AtomicUpdateOrdering
   ) {
+#if compiler(>=5.9) && $RawLayout
     _ = _storage.loadThenWrappingDecrement(
       by: operand,
       ordering: ordering)
+#else
+    _ = _Storage.atomicLoadThenWrappingDecrement(
+      by: operand,
+      at: _ptr,
+      ordering: ordering)
+#endif
   }
 }
diff --git a/Sources/Atomics/ManagedAtomic.swift b/Sources/Atomics/ManagedAtomic.swift
@@ -19,6 +19,7 @@ where Value.AtomicRepresentation.Value == Value {
   // (We'd need one set of implementations for the type equality condition, and
   // another for `Value: AtomicReference`.)
 
+#if compiler(>=5.9) && $RawLayout
   @usableFromInline
   internal let _storage: Atomic<Value>
 
@@ -28,6 +29,34 @@ where Value.AtomicRepresentation.Value == Value {
   public init(_ value: Value) {
     _storage = Atomic(value)
   }
+#else
+  @usableFromInline
+  internal typealias _Storage = Value.AtomicRepresentation
+
+  /// The atomic representation of the value stored inside.
+  ///
+  /// Warning: This ivar must only ever be accessed via `_ptr` after
+  /// its initialization.
+  @usableFromInline
+  internal var _storage: _Storage
+
+  /// Initialize a new managed atomic instance holding the specified initial
+  /// value.
+  @inline(__always) @_alwaysEmitIntoClient
+  public init(_ value: Value) {
+    _storage = _Storage(value)
+  }
+
+  deinit {
+    _ = _ptr.pointee.dispose()
+  }
+
+  @_alwaysEmitIntoClient @inline(__always)
+  internal var _ptr: UnsafeMutablePointer<_Storage> {
+    _getUnsafePointerToStoredProperties(self)
+      .assumingMemoryBound(to: _Storage.self)
+  }
+#endif
 }
 
 extension ManagedAtomic: @unchecked Sendable where Value: Sendable {}
@@ -43,7 +72,11 @@ extension ManagedAtomic {
   public func load(
     ordering: AtomicLoadOrdering
   ) -> Value {
+#if compiler(>=5.9) && $RawLayout
     _storage.load(ordering: ordering)
+#else
+    _Storage.atomicLoad(at: _ptr, ordering: ordering)
+#endif
   }
 
   /// Atomically sets the current value to `desired`, applying the specified
@@ -57,7 +90,11 @@ extension ManagedAtomic {
     _ desired: __owned Value,
     ordering: AtomicStoreOrdering
   ) {
+#if compiler(>=5.9) && $RawLayout
     _storage.store(desired, ordering: ordering)
+#else
+    _Storage.atomicStore(desired, at: _ptr, ordering: ordering)
+#endif
   }
 
   /// Atomically sets the current value to `desired` and returns the original
@@ -72,7 +109,11 @@ extension ManagedAtomic {
     _ desired: __owned Value,
     ordering: AtomicUpdateOrdering
   ) -> Value {
+#if compiler(>=5.9) && $RawLayout
     _storage.exchange(desired, ordering: ordering)
+#else
+    _Storage.atomicExchange(desired, at: _ptr, ordering: ordering)
+#endif
   }
 
   /// Perform an atomic compare and exchange operation on the current value,
@@ -105,8 +146,16 @@ extension ManagedAtomic {
     desired: __owned Value,
     ordering: AtomicUpdateOrdering
   ) -> (exchanged: Bool, original: Value) {
+#if compiler(>=5.9) && $RawLayout
     _storage.compareExchange(
       expected: expected, desired: desired, ordering: ordering)
+#else
+    _Storage.atomicCompareExchange(
+      expected: expected,
+      desired: desired,
+      at: _ptr,
+      ordering: ordering)
+#endif
   }
 
   /// Perform an atomic compare and exchange operation on the current value,
@@ -147,11 +196,20 @@ extension ManagedAtomic {
     successOrdering: AtomicUpdateOrdering,
     failureOrdering: AtomicLoadOrdering
   ) -> (exchanged: Bool, original: Value) {
+#if compiler(>=5.9) && $RawLayout
     _storage.compareExchange(
       expected: expected,
       desired: desired,
       successOrdering: successOrdering,
       failureOrdering: failureOrdering)
+#else
+    _Storage.atomicCompareExchange(
+      expected: expected,
+      desired: desired,
+      at: _ptr,
+      successOrdering: successOrdering,
+      failureOrdering: failureOrdering)
+#endif
   }
 
   /// Perform an atomic weak compare and exchange operation on the current
@@ -187,10 +245,18 @@ extension ManagedAtomic {
     desired: __owned Value,
     ordering: AtomicUpdateOrdering
   ) -> (exchanged: Bool, original: Value) {
+#if compiler(>=5.9) && $RawLayout
     _storage.weakCompareExchange(
       expected: expected,
       desired: desired,
       ordering: ordering)
+#else
+    _Storage.atomicWeakCompareExchange(
+      expected: expected,
+      desired: desired,
+      at: _ptr,
+      ordering: ordering)
+#endif
   }
 
   /// Perform an atomic weak compare and exchange operation on the current
@@ -234,10 +300,19 @@ extension ManagedAtomic {
     successOrdering: AtomicUpdateOrdering,
     failureOrdering: AtomicLoadOrdering
   ) -> (exchanged: Bool, original: Value) {
+#if compiler(>=5.9) && $RawLayout
     _storage.weakCompareExchange(
       expected: expected,
       desired: desired,
       successOrdering: successOrdering,
       failureOrdering: failureOrdering)
+#else
+    _Storage.atomicWeakCompareExchange(
+      expected: expected,
+      desired: desired,
+      at: _ptr,
+      successOrdering: successOrdering,
+      failureOrdering: failureOrdering)
+#endif
   }
 }
diff --git a/Sources/Atomics/autogenerated/AtomicBool.swift b/Sources/Atomics/autogenerated/AtomicBool.swift
diff --git a/Sources/Atomics/autogenerated/IntegerOperations.swift b/Sources/Atomics/autogenerated/IntegerOperations.swift
