[benchmark] Random(), SRand() → LFSR.init(), .next()

Author: lorentey

benchmark/single-source/ArraySubscript.swift

@@ -21,7 +21,7 @@ public let ArraySubscript = BenchmarkInfo(
 
 @inline(never)
 public func run_ArraySubscript(_ N: Int) {
-  SRand()
+  var lfsr = LFSR()
 
   let numArrays = 50
   let numArrayElements = 100
@@ -32,7 +32,7 @@ public func run_ArraySubscript(_ N: Int) {
     var arrays = [[Int]](repeating: [], count: numArrays)
     for i in 0..<numArrays {
       for _ in 0..<numArrayElements {
-        arrays[i].append(Int(truncatingIfNeeded: Random()))
+        arrays[i].append(Int(truncatingIfNeeded: lfsr.randInt()))
       }
     }
 

benchmark/single-source/MonteCarloE.swift

@@ -26,10 +26,12 @@ public let MonteCarloE = BenchmarkInfo(
   legacyFactor: 20)
 
 public func run_MonteCarloE(scale: Int) {
-  let N = 10_000*scale
-  var intervals = [Bool](repeating: false, count: N)
-  for _ in 1...N {
-    let pos = Int(UInt(truncatingIfNeeded: Random())%UInt(N))
+  var lfsr = LFSR()
+
+  let n = 10_000 * scale
+  var intervals = [Bool](repeating: false, count: n)
+  for _ in 1...n {
+    let pos = Int(UInt(truncatingIfNeeded: lfsr.next()) % UInt(n))
     intervals[pos] = true
   }
   let numEmptyIntervals = intervals.filter{!$0}.count

benchmark/single-source/MonteCarloPi.swift

@@ -19,12 +19,14 @@ public let MonteCarloPi = BenchmarkInfo(
   legacyFactor: 125)
 
 public func run_MonteCarloPi(scale: Int) {
+  var rng = LFSR()
+
   var pointsInside = 0
   let r = 10000
   let N = 4_000*scale
   for _ in 1...N {
-    let x = Int(truncatingIfNeeded: Random())%r
-    let y = Int(truncatingIfNeeded: Random())%r
+    let x = Int(truncatingIfNeeded: rng.next()) % r
+    let y = Int(truncatingIfNeeded: rng.next()) % r
     if x*x + y*y < r*r {
       pointsInside += 1
     }

benchmark/utils/TestsUtils.swift

@@ -211,14 +211,17 @@ extension BenchmarkInfo : Hashable {
 // This is just to drive benchmarks. I don't make any claim about its
 // strength. According to Wikipedia, it has the maximal period for a
 // 32-bit register.
-struct LFSR {
+public struct LFSR {
   // Set the register to some seed that I pulled out of a hat.
-  var lfsr : UInt32 = 0xb78978e7
+  var lfsr: UInt32 = 0xb78978e7
+
+  public init() {}
 
   mutating func shift() {
     lfsr = (lfsr >> 1) ^ (UInt32(bitPattern: -Int32((lfsr & 1))) & 0xD0000001)
   }
-  mutating func randInt() -> Int64 {
+
+  public mutating func next() -> Int64 {
     var result : UInt32 = 0
     for _ in 0..<32 {
       result = (result << 1) | (lfsr & 1)
@@ -231,12 +234,14 @@ struct LFSR {
 var lfsrRandomGenerator = LFSR()
 
 // Start the generator from the beginning
+@available(*, deprecated, renamed: "LFSR.init()")
 public func SRand() {
   lfsrRandomGenerator = LFSR()
 }
 
+@available(*, deprecated, renamed: "LFSR.next()")
 public func Random() -> Int64 {
-  return lfsrRandomGenerator.randInt()
+  return lfsrRandomGenerator.next()
 }
 
 // This is a fixed-increment version of Java 8's SplittableRandom generator.