Merge remote-tracking branch 'origin' into fix-build-warnings

Author: Gumichocopengin8

CHANGELOG.md

@@ -41,10 +41,26 @@ Swift Next
   print(s[0])
   ```
 
+**Add new entries to the top of this section, not here!**
+
 Swift 5.1
 ---------
 
-* [SE-0256][]:
+* [SE-0244][]:
+
+  Functions can now hide their concrete return type by declaring what protocols
+  it conforms to instead of specifying the exact return type:
+
+  ```
+  func makeMeACollection() -> some Collection {
+    return [1, 2, 3]
+  }
+  ```
+
+  Code that calls the function can use the interface of the protocol, but
+  does not have visibility into the underlying type.
+
+* [SE-0254][]:
 
   Subscripts can now be declared `static` or (inside classes) `class`.
 
@@ -246,6 +262,8 @@ Swift 5.1
 Swift 5.0
 ---------
 
+### 2019-03-25 (Xcode 10.2)
+
 * [SE-0235][]:
 
   The standard library now contains a `Result` type for manually propagating errors.
@@ -506,8 +524,6 @@ Swift 5.0
   }
   ```
 
-**Add new entries to the top of this section, not here!**
-
 Swift 4.2
 ---------
 
@@ -7649,7 +7665,10 @@ Swift 1.0
 [SE-0230]: <https://github.com/apple/swift-evolution/blob/master/proposals/0230-flatten-optional-try.md>
 [SE-0235]: <https://github.com/apple/swift-evolution/blob/master/proposals/0235-add-result.md>
 [SE-0242]: <https://github.com/apple/swift-evolution/blob/master/proposals/0242-default-values-memberwise.md>
+[SE-0244]: <https://github.com/apple/swift-evolution/blob/master/proposals/0244-opaque-result-types.md>
 [SE-0245]: <https://github.com/apple/swift-evolution/blob/master/proposals/0245-array-uninitialized-initializer.md>
+[SE-0252]: <https://github.com/apple/swift-evolution/blob/master/proposals/0252-keypath-dynamic-member-lookup.md>
+[SE-0254]: <https://github.com/apple/swift-evolution/blob/master/proposals/0254-static-subscripts.md>
 
 [SR-106]: <https://bugs.swift.org/browse/SR-106>
 [SR-419]: <https://bugs.swift.org/browse/SR-419>
@@ -7668,6 +7687,7 @@ Swift 1.0
 [SR-4248]: <https://bugs.swift.org/browse/SR-4248>
 [SR-5581]: <https://bugs.swift.org/browse/SR-5581>
 [SR-5719]: <https://bugs.swift.org/browse/SR-5719>
+[SR-6118]: <https://bugs.swift.org/browse/SR-6118>
 [SR-7139]: <https://bugs.swift.org/browse/SR-7139>
 [SR-7251]: <https://bugs.swift.org/browse/SR-7251>
 [SR-7601]: <https://bugs.swift.org/browse/SR-7601>

benchmark/CMakeLists.txt

@@ -43,6 +43,7 @@ set(SWIFT_BENCH_MODULES
     single-source/BinaryFloatingPointProperties
     single-source/BitCount
     single-source/Breadcrumbs
+    single-source/BucketSort
     single-source/ByteSwap
     single-source/COWTree
     single-source/COWArrayGuaranteedParameterOverhead
@@ -85,6 +86,7 @@ set(SWIFT_BENCH_MODULES
     single-source/ExistentialPerformance
     single-source/Fibonacci
     single-source/FlattenList
+    single-source/FloatingPointParsing
     single-source/FloatingPointPrinting
     single-source/Hanoi
     single-source/Hash

benchmark/Naming.md

@@ -89,7 +89,7 @@ relative comparison across the different axis of variation.
 
 </details><p><!-- spacer --></p></li>
 <li>
-<strong>Groups and types are <code>UpperCase</code>, methods are
+<strong>Groups, variants and types are <code>UpperCase</code>, methods are
 <code>lowerCase</code>.</strong>
 <details>
 

benchmark/single-source/Breadcrumbs.swift

@@ -45,23 +45,6 @@ extension String {
   }
 }
 
-let seed = 0x12345678
-
-/// A linear congruential PRNG.
-struct LCRNG: RandomNumberGenerator {
-  private var state: UInt64
-
-  init(seed: Int) {
-    state = UInt64(truncatingIfNeeded: seed)
-    for _ in 0..<10 { _ = next() }
-  }
-
-  mutating func next() -> UInt64 {
-    state = 2862933555777941757 &* state &+ 3037000493
-    return state
-  }
-}
-
 extension Collection {
   /// Returns a randomly ordered array of random non-overlapping index ranges
   /// that cover this collection entirely.
@@ -254,7 +237,7 @@ class UTF16ToIdx: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     let range = 0 ..< inputString.utf16.count
     inputOffsets = Array(range.shuffled(using: &rng).prefix(count))
   }
@@ -286,7 +269,7 @@ class IdxToUTF16: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputIndices = Array(inputString.indices.shuffled(using: &rng).prefix(count))
   }
 
@@ -318,7 +301,7 @@ class UTF16ToIdxRange: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputOffsets = (
       0 ..< inputString.utf16.count
     ).randomIndexRanges(count: count, using: &rng)
@@ -352,7 +335,7 @@ class IdxToUTF16Range: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputIndices = self.inputString.randomIndexRanges(count: count, using: &rng)
   }
 
@@ -384,7 +367,7 @@ class CopyUTF16CodeUnits: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputIndices = (
       0 ..< inputString.utf16.count
     ).randomIndexRanges(count: count, using: &rng)
@@ -425,7 +408,7 @@ class MutatedUTF16ToIdx: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var generator = LCRNG(seed: seed)
+    var generator = SplitMix64(seed: 42)
     let range = 0 ..< inputString.utf16.count
     inputOffsets = Array(range.shuffled(using: &generator).prefix(count))
   }
@@ -469,7 +452,7 @@ class MutatedIdxToUTF16: BenchmarkBase {
 
   override func setUp() {
     super.setUp()
-    var rng = LCRNG(seed: seed)
+    var rng = SplitMix64(seed: 42)
     inputIndices = Array(inputString.indices.shuffled(using: &rng).prefix(count))
   }
 

benchmark/single-source/BucketSort.swift

@@ -0,0 +1,131 @@
+//===--- BucketSort.swift -------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+// This benchmark demonstrates the benefits of ExistentialSpecializer
+// optimization pass. It's a generic version of the classic BucketSort algorithm
+// adapted from an original implementation from the Swift Algorithm Club.
+// See https://en.wikipedia.org/wiki/Bucket_sort and
+// https://github.com/raywenderlich/swift-algorithm-club/tree/master/Bucket%20Sort
+//
+// It sorts an array of generic `SortableItem`s. If the type of `sortingAlgo`
+// is not known to the call site at line 90, the `sort` method can not be
+// specialized to integer array sorting, which will lead to a huge performance
+// loss. Since `SortingAlgorithm` and `InsertionSort` are declared to be
+// `public` and the lines 89-91 can not be inlined in `bucketSort` (due to
+// inlining heuristic limitations), compiler without ExistentialSpecializer
+// optimization can not achieve this feat. With ExistentialSpecializer which
+// enables generic specialization recursively in a call chain, we're able to
+// specialize line 90 for `InsertionSort` on integers.
+
+import TestsUtils
+import Foundation
+
+public let BucketSort = BenchmarkInfo(
+  name: "BucketSort",
+  runFunction: run_BucketSort,
+  tags: [.validation, .algorithm],
+  setUpFunction: { blackHole(buckets) }
+)
+
+public protocol IntegerConvertible {
+    func convertToInt() -> Int
+}
+
+extension Int: IntegerConvertible, SortableItem {
+    public func convertToInt() -> Int {
+        return self
+    }
+}
+
+public protocol SortableItem: IntegerConvertible, Comparable { }
+
+public protocol SortingAlgorithm {
+    func sort<T: SortableItem>(_ items: [T]) -> [T]
+}
+
+public struct InsertionSort: SortingAlgorithm {
+    public func sort<T: SortableItem>(_ items: [T]) -> [T] {
+        var sortedItems = items
+        for i in 0 ..< sortedItems.count {
+            var j = i
+            while j > 0 && sortedItems[j-1] > sortedItems[j] {
+                let temp = sortedItems[j-1]
+                sortedItems[j-1] = sortedItems[j]
+                sortedItems[j] = temp
+                j -= 1
+            }
+        }
+        return sortedItems
+    }
+}
+
+func distribute<T>(_ item: T, bucketArray: inout [Bucket<T>]) {
+  let val = item.convertToInt()
+  let capacity = bucketArray.first!.capacity
+  let index = val / capacity
+  bucketArray[index].add(item)
+}
+
+struct Bucket<T: SortableItem> {
+  var items: [T]
+  let capacity: Int
+  init(capacity: Int) {
+    self.capacity = capacity
+    items = [T]()
+  }
+  mutating func add(_ item: T) {
+    if items.count < capacity {
+      items.append(item)
+    }
+  }
+  func sort(_ sortingAlgo: SortingAlgorithm) -> [T] {
+    return sortingAlgo.sort(items)
+  }
+}
+
+func bucketSort<T>(
+  _ items: [T], sortingAlgorithm: SortingAlgorithm, bucketArray: [Bucket<T>]
+) -> [T] {
+  var copyBucketArray = bucketArray
+  for item in items {
+    distribute(item, bucketArray: &copyBucketArray)
+  }
+  var sortedArray = [T]()
+  for bucket in copyBucketArray {
+    sortedArray += bucket.sort(sortingAlgorithm)
+  }
+  return sortedArray
+}
+
+func isAscending(_ a: [Int]) -> Bool {
+  return zip(a, a.dropFirst()).allSatisfy(<=)
+}
+
+let items: [Int] = {
+  var g = SplitMix64(seed: 42)
+  return (0..<10_000).map {_ in Int.random(in: 0..<1000, using: &g) }
+}()
+
+let buckets: [Bucket<Int>] = {
+  let bucketCount = 10
+  let maxValue = items.max()!.convertToInt()
+  let maxCapacity = Int(ceil(Double(maxValue + 1) / Double(bucketCount)))
+  return (0..<bucketCount).map { _ in Bucket<Int>(capacity: maxCapacity) }
+}()
+
+@inline(never)
+func run_BucketSort(_ N : Int) {
+  for _ in 0..<N {
+    let sortedArray = bucketSort(
+      items, sortingAlgorithm: InsertionSort(), bucketArray: buckets)
+    CheckResults(isAscending(sortedArray))
+  }
+}