Merge pull request #69 from glessard/unload

remove `load()` on `AtomicReference`

Author: glessard

.travis.yml

@@ -2,6 +2,10 @@ language: swift
 
 matrix:
   include:
+    - os: osx
+      osx_image: xcode8.3
+      env: SWIFT=3.1.1
+
     - os: osx
       osx_image: xcode9.2
       env: SWIFT=4.0.3
@@ -22,6 +26,11 @@ matrix:
       osx_image: xcode11.2
       env: SWIFT=5.1.2
 
+    - os: linux
+      dist: xenial
+      language: generic
+      env: SWIFT=3.1.1
+
     - os: linux
       dist: xenial
       language: generic

Package.swift

@@ -2,6 +2,8 @@
 
 import PackageDescription
 
+#if swift(>=4.0)
+
 let package = Package(
   name: "SwiftAtomics",
   products: [
@@ -16,3 +18,14 @@ let package = Package(
   ],
   swiftLanguageVersions: [.v3, .v4, .v4_2, .version("5")]
 )
+
+#else
+
+let package = Package(
+  name: "SwiftAtomics",
+  targets: [
+    Target(name: "SwiftAtomics", dependencies: ["CAtomics"]),
+  ]
+)
+
+#endif

README.md

@@ -1,5 +1,5 @@
 # swift-atomics [![Build Status](https://travis-ci.org/glessard/swift-atomics.svg?branch=master)](https://travis-ci.org/glessard/swift-atomics)
-Some atomic functions made available to Swift 3.2 and up, thanks to Clang
+Some atomic functions made available to Swift 3.1 and up, thanks to Clang
 
 The atomic functions available in `/usr/include/libkern/OSAtomic.h` are quite limiting in Swift, due to impedance mismatches between the type systems of Swift and C. Furthermore, some simple things such as a synchronized load or a synchronized store are not immediately available. On top of that, they have now been deprecated.
 

Sources/CAtomics/include/CAtomics.h

@@ -409,112 +409,27 @@ void CAtomicsThreadFence(enum MemoryOrder order)
   atomic_thread_fence(order);
 }
 
-// define struct + functions for nearly-atomic handling of Swift.Unmanaged
-
-#define __OPAQUE_UNMANAGED_LOCKED   (uintptr_t)0x7
-#define __OPAQUE_UNMANAGED_SPINMASK (char)0xc0
+// define struct + functions for handling of Swift.Unmanaged
 
 CLANG_ATOMICS_STRUCT(OpaqueUnmanagedHelper, atomic_uintptr_t, a, _Alignof(atomic_uintptr_t))
 CLANG_ATOMICS_IS_LOCK_FREE(OpaqueUnmanagedHelper)
 CLANG_ATOMICS_POINTER_INITIALIZE(OpaqueUnmanagedHelper, const void*, _Nullable)
-
-// this should only be used for unlocking
-CLANG_ATOMICS_POINTER_STORE(OpaqueUnmanagedHelper, const void*, _Nullable)
+CLANG_ATOMICS_POINTER_SWAP(OpaqueUnmanagedHelper, const void*, _Nullable)
 
 // this should only be used for debugging and testing
 CLANG_ATOMICS_POINTER_LOAD(OpaqueUnmanagedHelper, const void*, _Nullable)
 
-static __inline__ __attribute__((__always_inline__)) \
-const void *_Nullable CAtomicsUnmanagedLockAndLoad(OpaqueUnmanagedHelper *_Nonnull atomic)
-{ // load the pointer value, and leave the pointer either LOCKED or NULL; spin for the lock if necessary
-#ifndef __SSE2__
-  char c;
-  c = 0;
-#endif
-  uintptr_t pointer;
-  pointer = atomic_load_explicit(&(atomic->a), __ATOMIC_ACQUIRE);
-  do { // don't fruitlessly invalidate the cache line if the value is locked
-    while (pointer == __OPAQUE_UNMANAGED_LOCKED)
-    {
-#ifdef __SSE2__
-      _mm_pause();
-#else
-      c += 1;
-      if ((c&__OPAQUE_UNMANAGED_SPINMASK) != 0) { sched_yield(); }
-#endif
-      pointer = atomic_load_explicit(&(atomic->a), __ATOMIC_ACQUIRE);
-    }
-    // return immediately if pointer is NULL (importantly: without locking)
-    if (pointer == (uintptr_t) NULL) { return NULL; }
-  } while(!atomic_compare_exchange_weak_explicit(&(atomic->a), &pointer, __OPAQUE_UNMANAGED_LOCKED, __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE));
-
-  return (void*) pointer;
-}
-
-static __inline__ __attribute__((__always_inline__)) \
-__attribute__((overloadable)) \
-const void *_Nullable CAtomicsExchange(OpaqueUnmanagedHelper *_Nonnull atomic,
-                                       const void *_Nullable value, enum MemoryOrder order)
-{ // swap the pointer with `value`, spinning until the lock becomes unlocked if necessary
-#ifndef __SSE2__
-  char c;
-  c = 0;
-#endif
-  uintptr_t pointer;
-  pointer = atomic_load_explicit(&(atomic->a), order);
-  do { // don't fruitlessly invalidate the cache line if the value is locked
-    while (pointer == __OPAQUE_UNMANAGED_LOCKED)
-    {
-#ifdef __SSE2__
-      _mm_pause();
-#else
-      c += 1;
-      if ((c&__OPAQUE_UNMANAGED_SPINMASK) != 0) { sched_yield(); }
-#endif
-      pointer = atomic_load_explicit(&(atomic->a), order);
-    }
-  } while(!atomic_compare_exchange_weak_explicit(&(atomic->a), &pointer, (uintptr_t)value, order, order));
-
-  return (void*) pointer;
-}
-
 static __inline__ __attribute__((__always_inline__)) \
 __attribute__((overloadable)) \
 _Bool CAtomicsCompareAndExchange(OpaqueUnmanagedHelper *_Nonnull atomic,
                                  const void *_Nullable current, const void *_Nullable future,
                                  enum CASType type, enum MemoryOrder order)
 {
+  uintptr_t pointer = (uintptr_t) current;
   if(type == __ATOMIC_CAS_TYPE_WEAK)
-  {
-    uintptr_t pointer = (uintptr_t) current;
     return atomic_compare_exchange_weak_explicit(&(atomic->a), &pointer, (uintptr_t)future, order, memory_order_relaxed);
-  }
   else
-  { // we should consider that __OPAQUE_UNMANAGED_LOCKED is a spurious value
-#ifndef __SSE2__
-    char c;
-    c = 0;
-#endif
-    _Bool success;
-    while (true)
-    {
-      uintptr_t pointer = (uintptr_t) current;
-      success = atomic_compare_exchange_strong_explicit(&(atomic->a), &pointer, (uintptr_t)future, order, memory_order_relaxed);
-      if (pointer != __OPAQUE_UNMANAGED_LOCKED) { break; }
-
-      while (pointer == __OPAQUE_UNMANAGED_LOCKED)
-      { // don't fruitlessly invalidate the cache line if the value is locked
-#ifdef __SSE2__
-        _mm_pause();
-#else
-        c += 1;
-        if ((c&__OPAQUE_UNMANAGED_SPINMASK) != 0) { sched_yield(); }
-#endif
-        pointer = atomic_load_explicit(&(atomic->a), __ATOMIC_RELAXED);
-      }
-    }
-    return success;
-  }
+    return atomic_compare_exchange_strong_explicit(&(atomic->a), &pointer, (uintptr_t)future, order, memory_order_relaxed);
 }
 
 #endif

Sources/SwiftAtomics/atomics-reference.swift

@@ -14,6 +14,21 @@ import CAtomics
 
 import struct CAtomics.OpaqueUnmanagedHelper
 
+#if !swift(>=3.2)
+extension MemoryOrder
+{
+  @_versioned init(order: LoadMemoryOrder)
+  {
+    self = MemoryOrder.init(rawValue: order.rawValue) ?? .sequential
+  }
+
+  @_versioned init(order: StoreMemoryOrder)
+  {
+    self = MemoryOrder.init(rawValue: order.rawValue) ?? .sequential
+  }
+}
+#endif
+
 public struct AtomicReference<T: AnyObject>
 {
 #if swift(>=4.2)
@@ -79,7 +94,7 @@ extension AtomicReference
     }
     return false
   }
-#else
+#elseif swift(>=3.2)
   @inline(__always)
   public mutating func storeIfNil(_ reference: T, order: StoreMemoryOrder = .release) -> Bool
   {
@@ -91,6 +106,18 @@ extension AtomicReference
     }
     return false
   }
+#else
+  @inline(__always)
+  public mutating func storeIfNil(_ reference: T, order: StoreMemoryOrder = .sequential) -> Bool
+  {
+    let u = Unmanaged.passUnretained(reference)
+    if CAtomicsCompareAndExchange(&ptr, nil, u.toOpaque(), .strong, MemoryOrder(order: order))
+    {
+      _ = u.retain()
+      return true
+    }
+    return false
+  }
 #endif
 
 #if swift(>=4.2)
@@ -100,70 +127,19 @@ extension AtomicReference
     let pointer = CAtomicsExchange(&ptr, nil, MemoryOrder(rawValue: order.rawValue)!)
     return pointer.map { Unmanaged.fromOpaque($0).takeRetainedValue() }
   }
-#else
+#elseif swift(>=3.2)
   @inline(__always)
   public mutating func take(order: LoadMemoryOrder = .acquire) -> T?
   {
     let pointer = CAtomicsExchange(&ptr, nil, MemoryOrder(rawValue: order.rawValue)!)
     return pointer.map { Unmanaged.fromOpaque($0).takeRetainedValue() }
   }
-#endif
-
-#if swift(>=4.2)
-  /// load the reference currently stored in this AtomicReference
-  ///
-  /// This is *not* an atomic operation if the reference is non-nil.
-  /// In order to ensure the integrity of the automatic reference
-  /// counting, the AtomicReference gets locked (internally) until the
-  /// reference count has been incremented. The critical section
-  /// protected by the lock is extremely short (nanoseconds), but necessary.
-  ///
-  /// This is the only AtomicReference operation that needs a lock;
-  /// the others operations will spin until a `load` operation is complete,
-  /// but are otherwise atomic.
-  @inlinable
-  public mutating func load() -> T?
-  {
-    if let pointer = CAtomicsUnmanagedLockAndLoad(&ptr)
-    {
-      assert(CAtomicsLoad(&ptr, .acquire) == UnsafeRawPointer(bitPattern: 0x7))
-      CAtomicsThreadFence(.acquire)
-      let unmanaged = Unmanaged<T>.fromOpaque(pointer).retain()
-      // ensure the reference counting operation has occurred before unlocking,
-      // by performing our store operation with StoreMemoryOrder.release
-      CAtomicsThreadFence(.release)
-      CAtomicsStore(&ptr, pointer, .release)
-      return unmanaged.takeRetainedValue()
-    }
-    return nil
-  }
-#else
-  /// load the reference currently stored in this AtomicReference
-  ///
-  /// This is *not* an atomic operation if the reference is non-nil.
-  /// In order to ensure the integrity of the automatic reference
-  /// counting, the AtomicReference gets locked (internally) until the
-  /// reference count has been incremented. The critical section
-  /// protected by the lock is extremely short (nanoseconds), but necessary.
-  ///
-  /// This is the only AtomicReference operation that needs a lock;
-  /// the others operations will spin until a `load` operation is complete,
-  /// but are otherwise atomic.
+#else // swift 3.1
   @inline(__always)
-  public mutating func load() -> T?
+  public mutating func take(order: LoadMemoryOrder = .sequential) -> T?
   {
-    if let pointer = CAtomicsUnmanagedLockAndLoad(&ptr)
-    {
-      assert(CAtomicsLoad(&ptr, .acquire) == UnsafeRawPointer(bitPattern: 0x7))
-      CAtomicsThreadFence(.acquire)
-      let unmanaged = Unmanaged<T>.fromOpaque(pointer).retain()
-      // ensure the reference counting operation has occurred before unlocking,
-      // by performing our store operation with StoreMemoryOrder.release
-      CAtomicsThreadFence(.release)
-      CAtomicsStore(&ptr, pointer, .release)
-      return unmanaged.takeRetainedValue()
-    }
-    return nil
+    let pointer = CAtomicsExchange(&ptr, nil, MemoryOrder(order: order))
+    return pointer.map { Unmanaged.fromOpaque($0).takeRetainedValue() }
   }
 #endif