Use the "nearly divisionless" algorithm on all targets. (swiftlang#37920)

* Use the "nearly divisionless" algorithm on all targets.

We have multipliedFullWidth available everywhere now, so we don't need to carry around the old implementation on 32b targets.

Also adds a few more benchmarks for random number generation.

* Obscure the range boundaries for some of the new random value benchmarks.

When these are visible compile-time constants, the compiler is smart enough to evaluate the division in the "nearly divisionless" algorithm, which makes it completely divisionless. That's good, but it obscures what the runtime performance of the algorithm will be when the bounds are _not_ available as compile-time constants. Thus, for some of the newly-added benchmarks, we pass the upper bound through `identity` to hide it from the optimizer (this is imperfect, but it's the simplest tool we have).

We don't want to do this for all the tests for two reasons:
- compile-time constant bounds are a common case that should still be reflected in our testing
- we don't want to perturb existing benchmark results more than we have to.

Author: stephentyrone

benchmark/single-source/RandomValues.swift

@@ -23,10 +23,26 @@ public let RandomValues = [
     tags: [.api], legacyFactor: 100),
   BenchmarkInfo(name: "RandomIntegersLCG", runFunction: run_RandomIntegersLCG,
     tags: [.api]),
+  BenchmarkInfo(name: "RandomInt8Def", runFunction: run_RandomInt8Def,
+    tags: [.api], legacyFactor: 100),
+  BenchmarkInfo(name: "RandomInt8LCG", runFunction: run_RandomInt8LCG,
+    tags: [.api]),
+  BenchmarkInfo(name: "RandomInt64Def", runFunction: run_RandomInt64Def,
+    tags: [.api], legacyFactor: 100),
+  BenchmarkInfo(name: "RandomInt64LCG", runFunction: run_RandomInt64LCG,
+    tags: [.api]),
   BenchmarkInfo(name: "RandomDoubleDef", runFunction: run_RandomDoubleDef,
     tags: [.api], legacyFactor: 100),
   BenchmarkInfo(name: "RandomDoubleLCG", runFunction: run_RandomDoubleLCG,
-    tags: [.api], legacyFactor: 2),
+    tags: [.api]),
+  BenchmarkInfo(name: "RandomDoubleOpaqueDef", runFunction: run_RandomDoubleOpaqueDef,
+    tags: [.api], legacyFactor: 100),
+  BenchmarkInfo(name: "RandomDoubleOpaqueLCG", runFunction: run_RandomDoubleOpaqueLCG,
+    tags: [.api]),
+  BenchmarkInfo(name: "RandomDouble01Def", runFunction: run_RandomDouble01Def,
+    tags: [.api], legacyFactor: 100),
+  BenchmarkInfo(name: "RandomDouble01LCG", runFunction: run_RandomDouble01LCG,
+    tags: [.api]),
 ]
 
 /// A linear congruential PRNG.
@@ -49,19 +65,70 @@ public func run_RandomIntegersDef(_ N: Int) {
   for _ in 0 ..< N {
     var x = 0
     for _ in 0 ..< 1_000 {
-      x &+= Int.random(in: 0...10_000)
+      x &+= .random(in: 0...10_000)
     }
     blackHole(x)
   }
 }
 
 @inline(never)
 public func run_RandomIntegersLCG(_ N: Int) {
+  for _ in 0 ..< N {
+    var x = 0
+    var generator = LCRNG(seed: 0)
+    for _ in 0 ..< 100_000 {
+      x &+= .random(in: 0 ... 10_000, using: &generator)
+    }
+    blackHole(x)
+  }
+}
+
+@inline(never)
+public func run_RandomInt8Def(_ N: Int) {
+  for _ in 0 ..< N {
+    var x: Int8 = 0
+    for _ in 0 ..< 1_000 {
+      x &+= .random(in: -65 ... identity(65))
+    }
+    blackHole(x)
+  }
+}
+
+@inline(never)
+public func run_RandomInt8LCG(_ N: Int) {
+  for _ in 0 ..< N {
+    var x: Int8 = 0
+    var generator = LCRNG(seed: 0)
+    for _ in 0 ..< 100_000 {
+      x &+= .random(in: -65 ... identity(65), using: &generator)
+    }
+    blackHole(x)
+  }
+}
+
+@inline(never)
+public func run_RandomInt64Def(_ N: Int) {
+  for _ in 0 ..< N {
+    var x: Int64 = 0
+    for _ in 0 ..< 1_000 {
+      x &+= .random(in:
+        -5_000_000_000_000_000_000 ... identity(5_000_000_000_000_000_000)
+      )
+    }
+    blackHole(x)
+  }
+}
+
+@inline(never)
+public func run_RandomInt64LCG(_ N: Int) {
   for _ in 0 ..< N {
     var x: Int64 = 0
     var generator = LCRNG(seed: 0)
     for _ in 0 ..< 100_000 {
-      x &+= Int64.random(in: 0...10_000, using: &generator)
+      x &+= .random(in:
+        -5_000_000_000_000_000_000 ... identity(5_000_000_000_000_000_000),
+        using: &generator
+      )
     }
     blackHole(x)
   }
@@ -72,7 +139,7 @@ public func run_RandomDoubleDef(_ N: Int) {
   for _ in 0 ..< N {
     var x = 0.0
     for _ in 0 ..< 1_000 {
-      x += Double.random(in: -1000...1000)
+      x += .random(in: -1000 ... 1000)
     }
     blackHole(x)
   }
@@ -83,9 +150,56 @@ public func run_RandomDoubleLCG(_ N: Int) {
   for _ in 0 ..< N {
     var x = 0.0
     var generator = LCRNG(seed: 0)
-    for _ in 0 ..< 50_000 {
-      x += Double.random(in: -1000...1000, using: &generator)
+    for _ in 0 ..< 100_000 {
+      x += .random(in: -1000 ... 1000, using: &generator)
+    }
+    blackHole(x)
+  }
+}
+
+@inline(never)
+public func run_RandomDoubleOpaqueDef(_ N: Int) {
+  for _ in 0 ..< N {
+    var x = 0.0
+    for _ in 0 ..< 1_000 {
+      x += .random(in: -1000 ... identity(1000))
+    }
+    blackHole(x)
+  }
+}
+
+@inline(never)
+public func run_RandomDoubleOpaqueLCG(_ N: Int) {
+  for _ in 0 ..< N {
+    var x = 0.0
+    var generator = LCRNG(seed: 0)
+    for _ in 0 ..< 100_000 {
+      x += .random(in: -1000 ... identity(1000), using: &generator)
+    }
+    blackHole(x)
+  }
+}
+
+@inline(never)
+public func run_RandomDouble01Def(_ N: Int) {
+  for _ in 0 ..< N {
+    var x = 0.0
+    for _ in 0 ..< 1_000 {
+      x += .random(in: 0 ..< 1)
+    }
+    blackHole(x)
+  }
+}
+
+@inline(never)
+public func run_RandomDouble01LCG(_ N: Int) {
+  for _ in 0 ..< N {
+    var x = 0.0
+    var generator = LCRNG(seed: 0)
+    for _ in 0 ..< 100_000 {
+      x += .random(in: 0 ..< 1, using: &generator)
     }
     blackHole(x)
   }
 }
+ 

stdlib/public/core/Random.swift

@@ -103,17 +103,6 @@ extension RandomNumberGenerator {
     upperBound: T
   ) -> T {
     _precondition(upperBound != 0, "upperBound cannot be zero.")
-#if arch(i386) || arch(arm) || arch(arm64_32) // TODO(FIXME) SR-10912
-    let tmp = (T.max % upperBound) + 1
-    let range = tmp == upperBound ? 0 : tmp
-    var random: T = 0
-
-    repeat {
-      random = next()
-    } while random < range
-
-    return random % upperBound
-#else
     var random: T = next()
     var m = random.multipliedFullWidth(by: upperBound)
     if m.low < upperBound {
@@ -124,7 +113,6 @@ extension RandomNumberGenerator {
       }
     }
     return m.high
-#endif
   }
 }