Merge pull request #59959 from lorentey/duration-components-crash

[stdlib] Duration: Fix rare overflow trap in Int128.multipliedFullWidth

Author: lorentey

stdlib/public/core/Int128.swift.gyb

@@ -350,11 +350,24 @@ extension _${U}Int128: FixedWidthInteger {
   ) -> (high: Self, low: Magnitude) {
     let isNegative = Self.isSigned && (self._isNegative != other._isNegative)
 
+    func sum(_ x: Low, _ y: Low) -> (high: Low, low: Low) {
+      let (sum, overflow) = x.addingReportingOverflow(y)
+      return (overflow ? 1 : 0, sum)
+    }
+
     func sum(_ x: Low, _ y: Low, _ z: Low) -> (high: Low, low: Low) {
-      let (sum1, overflow1) = x.addingReportingOverflow(y)
-      let (sum2, overflow2) = sum1.addingReportingOverflow(z)
-      let carry: Low = (overflow1 ? 1 : 0) + (overflow2 ? 1 : 0)
-      return (carry, sum2)
+      let s1 = sum(x, y)
+      let s2 = sum(s1.low, z)
+      return (s1.high &+ s2.high, s2.low)
+    }
+
+    func sum(
+      _ x0: Low, _ x1: Low, _ x2: Low, _ x3: Low
+    ) -> (high: Low, low: Low) {
+      let s1 = sum(x0, x1)
+      let s2 = sum(x2, x3)
+      let s = sum(s1.low, s2.low)
+      return (s1.high &+ s2.high &+ s.high, s.low)
     }
 
     let lhs = self.magnitude
@@ -366,12 +379,14 @@ extension _${U}Int128: FixedWidthInteger {
     let d = rhs.high.multipliedFullWidth(by: lhs.high)
 
     let mid1 = sum(a.high, b.low, c.low)
-    let mid2 = sum(b.high, c.high, d.low)
+    let mid2 = sum(b.high, c.high, mid1.high, d.low)
 
-    let low = _UInt128(high: mid1.low, low: a.low)
     let high = _${U}Int128(
-      high: High(mid2.high + d.high),
-      low: mid1.high + mid2.low)
+      high: High(d.high &+ mid2.high), // Note: this addition will never wrap
+      low: mid2.low)
+    let low = _UInt128(
+      high: mid1.low,
+      low: a.low)
 
     if isNegative {
       let (lowComplement, overflow) = (~low).addingReportingOverflow(.one)

test/Concurrency/Runtime/clock.swift

@@ -9,17 +9,16 @@
 // UNSUPPORTED: back_deployment_runtime
 // UNSUPPORTED: back_deploy_concurrency
 
-// This test is disabled because it seems to require dedicated CPU access:
-// REQUIRES: rdar94451729
-
 import _Concurrency
 import StdlibUnittest
 
 var tests = TestSuite("Time")
 
 @main struct Main {
   static func main() async {
-    tests.test("ContinuousClock sleep") {
+    tests.test("ContinuousClock sleep")
+    .skip(.always("failed despite increased timeout (rdar://94451729)"))
+    .code {
       let clock = ContinuousClock()
       let elapsed = await clock.measure {
         try! await clock.sleep(until: .now + .milliseconds(100))
@@ -29,7 +28,9 @@ var tests = TestSuite("Time")
       expectLT(elapsed, .milliseconds(1000))
     }
 
-    tests.test("ContinuousClock sleep with tolerance") {
+    tests.test("ContinuousClock sleep with tolerance")
+    .skip(.always("failed despite increased timeout (rdar://94451729)"))
+    .code {
       let clock = ContinuousClock()
       let elapsed = await clock.measure {
         try! await clock.sleep(until: .now + .milliseconds(100), tolerance: .milliseconds(100))
@@ -39,15 +40,19 @@ var tests = TestSuite("Time")
       expectLT(elapsed, .milliseconds(2000))
     }
 
-    tests.test("ContinuousClock sleep longer") {
+    tests.test("ContinuousClock sleep longer")
+    .skip(.always("failed despite increased timeout (rdar://94451729)"))
+    .code {
       let elapsed = await ContinuousClock().measure {
         try! await Task.sleep(until: .now + .seconds(1), clock: .continuous)
       }
       expectGT(elapsed, .seconds(1) - .milliseconds(90))
       expectLT(elapsed, .seconds(1) + .milliseconds(1000))
     }
 
-    tests.test("SuspendingClock sleep") {
+    tests.test("SuspendingClock sleep")
+    .skip(.always("failed despite increased timeout (rdar://94451729)"))
+    .code {
       let clock = SuspendingClock()
       let elapsed = await clock.measure {
         try! await clock.sleep(until: .now + .milliseconds(100))
@@ -57,7 +62,9 @@ var tests = TestSuite("Time")
       expectLT(elapsed, .milliseconds(1000))
     }
 
-    tests.test("SuspendingClock sleep with tolerance") {
+    tests.test("SuspendingClock sleep with tolerance")
+    .skip(.always("failed despite increased timeout (rdar://94451729)"))
+    .code {
       let clock = SuspendingClock()
       let elapsed = await clock.measure {
         try! await clock.sleep(until: .now + .milliseconds(100), tolerance: .milliseconds(100))
@@ -67,7 +74,9 @@ var tests = TestSuite("Time")
       expectLT(elapsed, .milliseconds(2000))
     }
 
-    tests.test("SuspendingClock sleep longer") {
+    tests.test("SuspendingClock sleep longer")
+    .skip(.always("failed despite increased timeout (rdar://94451729)"))
+    .code {
       let elapsed = await SuspendingClock().measure {
         try! await Task.sleep(until: .now + .seconds(1), clock: .suspending)
       }
@@ -110,6 +119,44 @@ var tests = TestSuite("Time")
       expectEqual(twoSeconds, .seconds(2))
     }
 
+    tests.test("Duration components/whole second increments") {
+      for i in 0 ..< 1_000_000 {
+        let d = Duration.seconds(i)
+        let comps = d.components
+        expectEqual(comps.seconds, Int64(i))
+        expectEqual(comps.attoseconds, 0)
+      }
+    }
+
+    tests.test("Duration components/1ms increments") {
+      for i in 0 ..< 1_000_000 {
+        let d = Duration.milliseconds(i)
+        let comps = d.components
+        expectEqual(comps.seconds, Int64(i / 1000))
+        expectEqual(comps.attoseconds, Int64(i % 1000) * 1_000_000_000_000_000)
+      }
+    }
+
+    tests.test("Duration components/100µs increments") {
+      for i in 0 ..< 1_000_000 {
+        let ms = 100 * i
+        let d = Duration.microseconds(ms)
+        let comps = d.components
+        expectEqual(comps.seconds, Int64(ms / 1_000_000))
+        expectEqual(comps.attoseconds, Int64(ms % 1_000_000) * 1_000_000_000_000)
+      }
+    }
+
+    tests.test("Duration components/200ns increments") {
+      for i in 0 ..< 1_000_000 {
+        let ns = 200 * i
+        let d = Duration.nanoseconds(ns)
+        let comps = d.components
+        expectEqual(comps.seconds, Int64(ns / 1_000_000_000))
+        expectEqual(comps.attoseconds, Int64(ns % 1_000_000_000) * 1_000_000_000)
+      }
+    }
+
     await runAllTestsAsync()
   }
 }