Clean up internal properties by adding leading underscores, refine availability to a TBD marker macro, and break at 80 lines to match style

Author: phausler

stdlib/public/Concurrency/Clock.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 import Swift
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 public protocol Clock: Sendable {
   associatedtype Instant: InstantProtocol
 
@@ -22,7 +22,7 @@ public protocol Clock: Sendable {
 }
 
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 extension Clock {
   public func measure(_ work: () throws -> Void) rethrows -> Instant.Interval {
     let start = now
@@ -41,23 +41,23 @@ extension Clock {
   }
 }
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 @usableFromInline
 enum swift_clock_id: Int32 {
   case continuous = 1
   case realtime = 2
   case suspending = 3
 }
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 @_silgen_name("swift_get_time")
 @usableFromInline
 internal func _getTime(
   seconds: UnsafeMutablePointer<Int64>, 
   nanoseconds: UnsafeMutablePointer<Int64>,
   clock: swift_clock_id)
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 @_silgen_name("swift_get_clock_res")
 @usableFromInline
 internal func _getClockRes(

stdlib/public/Concurrency/ContinuousClock.swift

@@ -11,26 +11,26 @@
 //===----------------------------------------------------------------------===//
 import Swift
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 public struct ContinuousClock {
   public struct Instant: Codable, Sendable {
-    var value: Duration
+    internal var _value: Duration
 
-    init(_ value: Duration) {
-      self.value = value
+    internal init(_value: Duration) {
+      self._value = _value
     }
   }
 
   public init() { }
 }
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 extension Clock where Self == ContinuousClock {
-  @available(SwiftStdlib 5.1, *)
+  @available(SwiftStdlib 9999, *)
   public static var continuous: ContinuousClock { return ContinuousClock() }
 }
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 extension ContinuousClock: Clock {
   public var now: ContinuousClock.Instant {
     ContinuousClock.now
@@ -53,45 +53,45 @@ extension ContinuousClock: Clock {
       seconds: &seconds, 
       nanoseconds: &nanoseconds, 
       clock: .continuous)
-    return ContinuousClock.Instant(
+    return ContinuousClock.Instant(_value:
       .seconds(seconds) + .nanoseconds(nanoseconds))
   }
 
   public func sleep(
     until deadline: Instant, tolerance: Duration? = nil
   ) async throws {
-    try await Task.sleep(until: 
-      deadline.value.seconds, deadline.value.nanoseconds, 
+    try await Task._sleep(until: 
+      deadline._value.seconds, deadline._value.nanoseconds, 
       tolerance: tolerance, 
       clock: .continuous)
   }
 }
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 extension ContinuousClock.Instant: InstantProtocol {
   public static var now: ContinuousClock.Instant { ContinuousClock.now }
 
   public func advanced(by duration: Duration) -> ContinuousClock.Instant {
-    return ContinuousClock.Instant(value + duration)
+    return ContinuousClock.Instant(_value: _value + duration)
   }
 
   public func duration(to other: ContinuousClock.Instant) -> Duration {
-    other.value - value
+    other._value - _value
   }
 
   public func hash(into hasher: inout Hasher) {
-    hasher.combine(value)
+    hasher.combine(_value)
   }
 
   public static func == (
     _ lhs: ContinuousClock.Instant, _ rhs: ContinuousClock.Instant
   ) -> Bool {
-    return lhs.value == rhs.value
+    return lhs._value == rhs._value
   }
 
   public static func < (
     _ lhs: ContinuousClock.Instant, _ rhs: ContinuousClock.Instant
   ) -> Bool {
-    return lhs.value < rhs.value
+    return lhs._value < rhs._value
   }
 }

stdlib/public/Concurrency/SuspendingClock.swift

@@ -11,25 +11,25 @@
 //===----------------------------------------------------------------------===//
 import Swift
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 public struct SuspendingClock {
   public struct Instant: Codable, Sendable {
-    var value: Duration
+    internal var _value: Duration
 
-    init(_ value: Duration) {
-      self.value = value
+    internal init(_value: Duration) {
+      self._value = _value
     }
   }
 
   public init() { }
 }
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 extension Clock where Self == SuspendingClock {
   public static var suspending: SuspendingClock { return SuspendingClock() }
 }
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 extension SuspendingClock: Clock {
   public var now: SuspendingClock.Instant {
     SuspendingClock.now
@@ -42,7 +42,7 @@ extension SuspendingClock: Clock {
       seconds: &seconds, 
       nanoseconds: &nanoseconds, 
       clock: .continuous)
-    return SuspendingClock.Instant(
+    return SuspendingClock.Instant(_value:
       .seconds(seconds) + .nanoseconds(nanoseconds))
   }
 
@@ -59,39 +59,39 @@ extension SuspendingClock: Clock {
   public func sleep(
     until deadline: Instant, tolerance: Duration? = nil
   ) async throws {
-    try await Task.sleep(until: 
-      deadline.value.seconds, deadline.value.nanoseconds, 
+    try await Task._sleep(until: 
+      deadline._value.seconds, deadline._value.nanoseconds, 
       tolerance: tolerance, 
       clock: .suspending)
   }
 }
 
-@available(SwiftStdlib 5.1, *)
+@available(SwiftStdlib 9999, *)
 extension SuspendingClock.Instant: InstantProtocol {
   public static var now: SuspendingClock.Instant { SuspendingClock().now }
 
   public func advanced(by duration: Duration) -> SuspendingClock.Instant {
-    SuspendingClock.Instant(value + duration)
+    SuspendingClock.Instant(_value: _value + duration)
   }
 
   public func duration(to other: SuspendingClock.Instant) -> Duration {
-    other.value - value
+    other._value - _value
   }
 
   public func hash(into hasher: inout Hasher) {
-    hasher.combine(value)
+    hasher.combine(_value)
   }
 
   public static func == (
     _ lhs: SuspendingClock.Instant, _ rhs: SuspendingClock.Instant
   ) -> Bool {
-    return lhs.value == rhs.value
+    return lhs._value == rhs._value
   }
 
   public static func < (
     _ lhs: SuspendingClock.Instant, _ rhs: SuspendingClock.Instant
   ) -> Bool {
-    return lhs.value < rhs.value
+    return lhs._value < rhs._value
   }
 }
 

stdlib/public/Concurrency/TaskSleep.swift

@@ -20,7 +20,8 @@ extension Task where Success == Never, Failure == Never {
   ///
   /// This function doesn't block the underlying thread.
   public static func sleep(_ duration: UInt64) async {
-    return await Builtin.withUnsafeContinuation { (continuation: Builtin.RawUnsafeContinuation) -> Void in
+    return await Builtin.withUnsafeContinuation { 
+      (continuation: Builtin.RawUnsafeContinuation) -> Void in
       let job = _taskCreateNullaryContinuationJob(
           priority: Int(Task.currentPriority.rawValue),
           continuation: continuation)
@@ -201,11 +202,104 @@ extension Task where Success == Never, Failure == Never {
   ///
   /// This function doesn't block the underlying thread.
   public static func sleep(nanoseconds duration: UInt64) async throws {
-    let clock = ContinuousClock()
-    try await Task.sleep(until: clock.now + .nanoseconds(duration), clock: clock)
+    // Allocate storage for the storage word.
+    let wordPtr = UnsafeMutablePointer<Builtin.Word>.allocate(capacity: 1)
+
+    // Initialize the flag word to "not started", which means the continuation
+    // has neither been created nor completed.
+    Builtin.atomicstore_seqcst_Word(
+        wordPtr._rawValue, SleepState.notStarted.word._builtinWordValue)
+
+    do {
+      // Install a cancellation handler to resume the continuation by
+      // throwing CancellationError.
+      try await withTaskCancellationHandler {
+        let _: () = try await withUnsafeThrowingContinuation { continuation in
+          while true {
+            let state = SleepState(loading: wordPtr)
+            switch state {
+            case .notStarted:
+              // The word that describes the active continuation state.
+              let continuationWord =
+                SleepState.activeContinuation(continuation).word
+
+              // Try to swap in the continuation word.
+              let (_, won) = Builtin.cmpxchg_seqcst_seqcst_Word(
+                  wordPtr._rawValue,
+                  state.word._builtinWordValue,
+                  continuationWord._builtinWordValue)
+              if !Bool(_builtinBooleanLiteral: won) {
+                // Keep trying!
+                continue
+              }
+
+              // Create a task that resumes the continuation normally if it
+              // finishes first. Enqueue it directly with the delay, so it fires
+              // when we're done sleeping.
+              let sleepTaskFlags = taskCreateFlags(
+                priority: nil, isChildTask: false, copyTaskLocals: false,
+                inheritContext: false, enqueueJob: false,
+                addPendingGroupTaskUnconditionally: false)
+              let (sleepTask, _) = Builtin.createAsyncTask(sleepTaskFlags) {
+                onSleepWake(wordPtr)
+              }
+              _enqueueJobGlobalWithDelay(
+                  duration, Builtin.convertTaskToJob(sleepTask))
+              return
+
+            case .activeContinuation, .finished:
+              fatalError("Impossible to have multiple active continuations")
+
+            case .cancelled:
+              fatalError("Impossible to have cancelled before we began")
+
+            case .cancelledBeforeStarted:
+              // Finish the continuation normally. We'll throw later, after
+              // we clean up.
+              continuation.resume()
+              return
+          }
+        }
+        }
+      } onCancel: {
+        onSleepCancel(wordPtr)
+      }
+
+      // Determine whether we got cancelled before we even started.
+      let cancelledBeforeStarted: Bool
+      switch SleepState(loading: wordPtr) {
+      case .notStarted, .activeContinuation, .cancelled:
+        fatalError("Invalid state for non-cancelled sleep task")
+
+      case .cancelledBeforeStarted:
+        cancelledBeforeStarted = true
+
+      case .finished:
+        cancelledBeforeStarted = false
+      }
+
+      // We got here without being cancelled, so deallocate the storage for
+      // the flag word and continuation.
+      wordPtr.deallocate()
+
+      // If we got cancelled before we even started, through the cancellation
+      // error now.
+      if cancelledBeforeStarted {
+        throw _Concurrency.CancellationError()
+      }
+    } catch {
+      // The task was cancelled; propagate the error. The "on wake" task is
+      // responsible for deallocating the flag word and continuation, if it's
+      // still running.
+      throw error
+    }
   }
 
-  static func sleep(until seconds: Int64, _ nanoseconds: Int64, tolerance: Duration?, clock: swift_clock_id) async throws {
+  @available(SwiftStdlib 9999, *)
+  internal static func _sleep(
+    until seconds: Int64, _ nanoseconds: Int64, 
+    tolerance: Duration?, 
+    clock: swift_clock_id) async throws {
     // Allocate storage for the storage word.
     let wordPtr = UnsafeMutablePointer<Builtin.Word>.allocate(capacity: 1)
 
@@ -303,7 +397,12 @@ extension Task where Success == Never, Failure == Never {
     }
   }
 
-  public static func sleep<C: Clock>(until deadine: C.Instant, tolerance: C.Instant.Interval? = nil, clock: C) async throws {
+  @available(SwiftStdlib 9999, *)
+  public static func sleep<C: Clock>(
+    until deadine: C.Instant, 
+    tolerance: C.Instant.Interval? = nil, 
+    clock: C
+  ) async throws {
     try await clock.sleep(until: deadine, tolerance: tolerance)
   }
 }